1e5dd7070Spatrick //===--- CGExprAgg.cpp - Emit LLVM Code from Aggregate Expressions --------===//
2e5dd7070Spatrick //
3e5dd7070Spatrick // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4e5dd7070Spatrick // See https://llvm.org/LICENSE.txt for license information.
5e5dd7070Spatrick // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6e5dd7070Spatrick //
7e5dd7070Spatrick //===----------------------------------------------------------------------===//
8e5dd7070Spatrick //
9e5dd7070Spatrick // This contains code to emit Aggregate Expr nodes as LLVM code.
10e5dd7070Spatrick //
11e5dd7070Spatrick //===----------------------------------------------------------------------===//
12e5dd7070Spatrick
13e5dd7070Spatrick #include "CGCXXABI.h"
14e5dd7070Spatrick #include "CGObjCRuntime.h"
15e5dd7070Spatrick #include "CodeGenFunction.h"
16e5dd7070Spatrick #include "CodeGenModule.h"
17e5dd7070Spatrick #include "ConstantEmitter.h"
18ec727ea7Spatrick #include "TargetInfo.h"
19e5dd7070Spatrick #include "clang/AST/ASTContext.h"
20e5dd7070Spatrick #include "clang/AST/Attr.h"
21e5dd7070Spatrick #include "clang/AST/DeclCXX.h"
22e5dd7070Spatrick #include "clang/AST/DeclTemplate.h"
23e5dd7070Spatrick #include "clang/AST/StmtVisitor.h"
24e5dd7070Spatrick #include "llvm/IR/Constants.h"
25e5dd7070Spatrick #include "llvm/IR/Function.h"
26e5dd7070Spatrick #include "llvm/IR/GlobalVariable.h"
27e5dd7070Spatrick #include "llvm/IR/IntrinsicInst.h"
28e5dd7070Spatrick #include "llvm/IR/Intrinsics.h"
29e5dd7070Spatrick using namespace clang;
30e5dd7070Spatrick using namespace CodeGen;
31e5dd7070Spatrick
32e5dd7070Spatrick //===----------------------------------------------------------------------===//
33e5dd7070Spatrick // Aggregate Expression Emitter
34e5dd7070Spatrick //===----------------------------------------------------------------------===//
35e5dd7070Spatrick
36e5dd7070Spatrick namespace {
37e5dd7070Spatrick class AggExprEmitter : public StmtVisitor<AggExprEmitter> {
38e5dd7070Spatrick CodeGenFunction &CGF;
39e5dd7070Spatrick CGBuilderTy &Builder;
40e5dd7070Spatrick AggValueSlot Dest;
41e5dd7070Spatrick bool IsResultUnused;
42e5dd7070Spatrick
EnsureSlot(QualType T)43e5dd7070Spatrick AggValueSlot EnsureSlot(QualType T) {
44e5dd7070Spatrick if (!Dest.isIgnored()) return Dest;
45e5dd7070Spatrick return CGF.CreateAggTemp(T, "agg.tmp.ensured");
46e5dd7070Spatrick }
EnsureDest(QualType T)47e5dd7070Spatrick void EnsureDest(QualType T) {
48e5dd7070Spatrick if (!Dest.isIgnored()) return;
49e5dd7070Spatrick Dest = CGF.CreateAggTemp(T, "agg.tmp.ensured");
50e5dd7070Spatrick }
51e5dd7070Spatrick
52e5dd7070Spatrick // Calls `Fn` with a valid return value slot, potentially creating a temporary
53e5dd7070Spatrick // to do so. If a temporary is created, an appropriate copy into `Dest` will
54e5dd7070Spatrick // be emitted, as will lifetime markers.
55e5dd7070Spatrick //
56e5dd7070Spatrick // The given function should take a ReturnValueSlot, and return an RValue that
57e5dd7070Spatrick // points to said slot.
58e5dd7070Spatrick void withReturnValueSlot(const Expr *E,
59e5dd7070Spatrick llvm::function_ref<RValue(ReturnValueSlot)> Fn);
60e5dd7070Spatrick
61e5dd7070Spatrick public:
AggExprEmitter(CodeGenFunction & cgf,AggValueSlot Dest,bool IsResultUnused)62e5dd7070Spatrick AggExprEmitter(CodeGenFunction &cgf, AggValueSlot Dest, bool IsResultUnused)
63e5dd7070Spatrick : CGF(cgf), Builder(CGF.Builder), Dest(Dest),
64e5dd7070Spatrick IsResultUnused(IsResultUnused) { }
65e5dd7070Spatrick
66e5dd7070Spatrick //===--------------------------------------------------------------------===//
67e5dd7070Spatrick // Utilities
68e5dd7070Spatrick //===--------------------------------------------------------------------===//
69e5dd7070Spatrick
70e5dd7070Spatrick /// EmitAggLoadOfLValue - Given an expression with aggregate type that
71e5dd7070Spatrick /// represents a value lvalue, this method emits the address of the lvalue,
72e5dd7070Spatrick /// then loads the result into DestPtr.
73e5dd7070Spatrick void EmitAggLoadOfLValue(const Expr *E);
74e5dd7070Spatrick
75e5dd7070Spatrick enum ExprValueKind {
76e5dd7070Spatrick EVK_RValue,
77e5dd7070Spatrick EVK_NonRValue
78e5dd7070Spatrick };
79e5dd7070Spatrick
80e5dd7070Spatrick /// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
81e5dd7070Spatrick /// SrcIsRValue is true if source comes from an RValue.
82e5dd7070Spatrick void EmitFinalDestCopy(QualType type, const LValue &src,
83e5dd7070Spatrick ExprValueKind SrcValueKind = EVK_NonRValue);
84e5dd7070Spatrick void EmitFinalDestCopy(QualType type, RValue src);
85e5dd7070Spatrick void EmitCopy(QualType type, const AggValueSlot &dest,
86e5dd7070Spatrick const AggValueSlot &src);
87e5dd7070Spatrick
88e5dd7070Spatrick void EmitMoveFromReturnSlot(const Expr *E, RValue Src);
89e5dd7070Spatrick
90*12c85518Srobert void EmitArrayInit(Address DestPtr, llvm::ArrayType *AType, QualType ArrayQTy,
91*12c85518Srobert Expr *ExprToVisit, ArrayRef<Expr *> Args,
92*12c85518Srobert Expr *ArrayFiller);
93e5dd7070Spatrick
needsGC(QualType T)94e5dd7070Spatrick AggValueSlot::NeedsGCBarriers_t needsGC(QualType T) {
95e5dd7070Spatrick if (CGF.getLangOpts().getGC() && TypeRequiresGCollection(T))
96e5dd7070Spatrick return AggValueSlot::NeedsGCBarriers;
97e5dd7070Spatrick return AggValueSlot::DoesNotNeedGCBarriers;
98e5dd7070Spatrick }
99e5dd7070Spatrick
100e5dd7070Spatrick bool TypeRequiresGCollection(QualType T);
101e5dd7070Spatrick
102e5dd7070Spatrick //===--------------------------------------------------------------------===//
103e5dd7070Spatrick // Visitor Methods
104e5dd7070Spatrick //===--------------------------------------------------------------------===//
105e5dd7070Spatrick
Visit(Expr * E)106e5dd7070Spatrick void Visit(Expr *E) {
107e5dd7070Spatrick ApplyDebugLocation DL(CGF, E);
108e5dd7070Spatrick StmtVisitor<AggExprEmitter>::Visit(E);
109e5dd7070Spatrick }
110e5dd7070Spatrick
VisitStmt(Stmt * S)111e5dd7070Spatrick void VisitStmt(Stmt *S) {
112e5dd7070Spatrick CGF.ErrorUnsupported(S, "aggregate expression");
113e5dd7070Spatrick }
VisitParenExpr(ParenExpr * PE)114e5dd7070Spatrick void VisitParenExpr(ParenExpr *PE) { Visit(PE->getSubExpr()); }
VisitGenericSelectionExpr(GenericSelectionExpr * GE)115e5dd7070Spatrick void VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
116e5dd7070Spatrick Visit(GE->getResultExpr());
117e5dd7070Spatrick }
VisitCoawaitExpr(CoawaitExpr * E)118e5dd7070Spatrick void VisitCoawaitExpr(CoawaitExpr *E) {
119e5dd7070Spatrick CGF.EmitCoawaitExpr(*E, Dest, IsResultUnused);
120e5dd7070Spatrick }
VisitCoyieldExpr(CoyieldExpr * E)121e5dd7070Spatrick void VisitCoyieldExpr(CoyieldExpr *E) {
122e5dd7070Spatrick CGF.EmitCoyieldExpr(*E, Dest, IsResultUnused);
123e5dd7070Spatrick }
VisitUnaryCoawait(UnaryOperator * E)124e5dd7070Spatrick void VisitUnaryCoawait(UnaryOperator *E) { Visit(E->getSubExpr()); }
VisitUnaryExtension(UnaryOperator * E)125e5dd7070Spatrick void VisitUnaryExtension(UnaryOperator *E) { Visit(E->getSubExpr()); }
VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr * E)126e5dd7070Spatrick void VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E) {
127e5dd7070Spatrick return Visit(E->getReplacement());
128e5dd7070Spatrick }
129e5dd7070Spatrick
VisitConstantExpr(ConstantExpr * E)130e5dd7070Spatrick void VisitConstantExpr(ConstantExpr *E) {
131*12c85518Srobert EnsureDest(E->getType());
132*12c85518Srobert
133ec727ea7Spatrick if (llvm::Value *Result = ConstantEmitter(CGF).tryEmitConstantExpr(E)) {
134ec727ea7Spatrick CGF.EmitAggregateStore(Result, Dest.getAddress(),
135ec727ea7Spatrick E->getType().isVolatileQualified());
136ec727ea7Spatrick return;
137ec727ea7Spatrick }
138e5dd7070Spatrick return Visit(E->getSubExpr());
139e5dd7070Spatrick }
140e5dd7070Spatrick
141e5dd7070Spatrick // l-values.
VisitDeclRefExpr(DeclRefExpr * E)142e5dd7070Spatrick void VisitDeclRefExpr(DeclRefExpr *E) { EmitAggLoadOfLValue(E); }
VisitMemberExpr(MemberExpr * ME)143e5dd7070Spatrick void VisitMemberExpr(MemberExpr *ME) { EmitAggLoadOfLValue(ME); }
VisitUnaryDeref(UnaryOperator * E)144e5dd7070Spatrick void VisitUnaryDeref(UnaryOperator *E) { EmitAggLoadOfLValue(E); }
VisitStringLiteral(StringLiteral * E)145e5dd7070Spatrick void VisitStringLiteral(StringLiteral *E) { EmitAggLoadOfLValue(E); }
146e5dd7070Spatrick void VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
VisitArraySubscriptExpr(ArraySubscriptExpr * E)147e5dd7070Spatrick void VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
148e5dd7070Spatrick EmitAggLoadOfLValue(E);
149e5dd7070Spatrick }
VisitPredefinedExpr(const PredefinedExpr * E)150e5dd7070Spatrick void VisitPredefinedExpr(const PredefinedExpr *E) {
151e5dd7070Spatrick EmitAggLoadOfLValue(E);
152e5dd7070Spatrick }
153e5dd7070Spatrick
154e5dd7070Spatrick // Operators.
155e5dd7070Spatrick void VisitCastExpr(CastExpr *E);
156e5dd7070Spatrick void VisitCallExpr(const CallExpr *E);
157e5dd7070Spatrick void VisitStmtExpr(const StmtExpr *E);
158e5dd7070Spatrick void VisitBinaryOperator(const BinaryOperator *BO);
159e5dd7070Spatrick void VisitPointerToDataMemberBinaryOperator(const BinaryOperator *BO);
160e5dd7070Spatrick void VisitBinAssign(const BinaryOperator *E);
161e5dd7070Spatrick void VisitBinComma(const BinaryOperator *E);
162e5dd7070Spatrick void VisitBinCmp(const BinaryOperator *E);
VisitCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator * E)163e5dd7070Spatrick void VisitCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *E) {
164e5dd7070Spatrick Visit(E->getSemanticForm());
165e5dd7070Spatrick }
166e5dd7070Spatrick
167e5dd7070Spatrick void VisitObjCMessageExpr(ObjCMessageExpr *E);
VisitObjCIvarRefExpr(ObjCIvarRefExpr * E)168e5dd7070Spatrick void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
169e5dd7070Spatrick EmitAggLoadOfLValue(E);
170e5dd7070Spatrick }
171e5dd7070Spatrick
172e5dd7070Spatrick void VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E);
173e5dd7070Spatrick void VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO);
174e5dd7070Spatrick void VisitChooseExpr(const ChooseExpr *CE);
175e5dd7070Spatrick void VisitInitListExpr(InitListExpr *E);
176*12c85518Srobert void VisitCXXParenListOrInitListExpr(Expr *ExprToVisit, ArrayRef<Expr *> Args,
177*12c85518Srobert FieldDecl *InitializedFieldInUnion,
178*12c85518Srobert Expr *ArrayFiller);
179e5dd7070Spatrick void VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E,
180e5dd7070Spatrick llvm::Value *outerBegin = nullptr);
181e5dd7070Spatrick void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
VisitNoInitExpr(NoInitExpr * E)182e5dd7070Spatrick void VisitNoInitExpr(NoInitExpr *E) { } // Do nothing.
VisitCXXDefaultArgExpr(CXXDefaultArgExpr * DAE)183e5dd7070Spatrick void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
184e5dd7070Spatrick CodeGenFunction::CXXDefaultArgExprScope Scope(CGF, DAE);
185e5dd7070Spatrick Visit(DAE->getExpr());
186e5dd7070Spatrick }
VisitCXXDefaultInitExpr(CXXDefaultInitExpr * DIE)187e5dd7070Spatrick void VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
188e5dd7070Spatrick CodeGenFunction::CXXDefaultInitExprScope Scope(CGF, DIE);
189e5dd7070Spatrick Visit(DIE->getExpr());
190e5dd7070Spatrick }
191e5dd7070Spatrick void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
192e5dd7070Spatrick void VisitCXXConstructExpr(const CXXConstructExpr *E);
193e5dd7070Spatrick void VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E);
194e5dd7070Spatrick void VisitLambdaExpr(LambdaExpr *E);
195e5dd7070Spatrick void VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E);
196e5dd7070Spatrick void VisitExprWithCleanups(ExprWithCleanups *E);
197e5dd7070Spatrick void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
VisitCXXTypeidExpr(CXXTypeidExpr * E)198e5dd7070Spatrick void VisitCXXTypeidExpr(CXXTypeidExpr *E) { EmitAggLoadOfLValue(E); }
199e5dd7070Spatrick void VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
200e5dd7070Spatrick void VisitOpaqueValueExpr(OpaqueValueExpr *E);
201e5dd7070Spatrick
VisitPseudoObjectExpr(PseudoObjectExpr * E)202e5dd7070Spatrick void VisitPseudoObjectExpr(PseudoObjectExpr *E) {
203e5dd7070Spatrick if (E->isGLValue()) {
204e5dd7070Spatrick LValue LV = CGF.EmitPseudoObjectLValue(E);
205e5dd7070Spatrick return EmitFinalDestCopy(E->getType(), LV);
206e5dd7070Spatrick }
207e5dd7070Spatrick
208*12c85518Srobert AggValueSlot Slot = EnsureSlot(E->getType());
209*12c85518Srobert bool NeedsDestruction =
210*12c85518Srobert !Slot.isExternallyDestructed() &&
211*12c85518Srobert E->getType().isDestructedType() == QualType::DK_nontrivial_c_struct;
212*12c85518Srobert if (NeedsDestruction)
213*12c85518Srobert Slot.setExternallyDestructed();
214*12c85518Srobert CGF.EmitPseudoObjectRValue(E, Slot);
215*12c85518Srobert if (NeedsDestruction)
216*12c85518Srobert CGF.pushDestroy(QualType::DK_nontrivial_c_struct, Slot.getAddress(),
217*12c85518Srobert E->getType());
218e5dd7070Spatrick }
219e5dd7070Spatrick
220e5dd7070Spatrick void VisitVAArgExpr(VAArgExpr *E);
221*12c85518Srobert void VisitCXXParenListInitExpr(CXXParenListInitExpr *E);
222*12c85518Srobert void VisitCXXParenListOrInitListExpr(Expr *ExprToVisit, ArrayRef<Expr *> Args,
223*12c85518Srobert Expr *ArrayFiller);
224e5dd7070Spatrick
225e5dd7070Spatrick void EmitInitializationToLValue(Expr *E, LValue Address);
226e5dd7070Spatrick void EmitNullInitializationToLValue(LValue Address);
227e5dd7070Spatrick // case Expr::ChooseExprClass:
VisitCXXThrowExpr(const CXXThrowExpr * E)228e5dd7070Spatrick void VisitCXXThrowExpr(const CXXThrowExpr *E) { CGF.EmitCXXThrowExpr(E); }
VisitAtomicExpr(AtomicExpr * E)229e5dd7070Spatrick void VisitAtomicExpr(AtomicExpr *E) {
230e5dd7070Spatrick RValue Res = CGF.EmitAtomicExpr(E);
231e5dd7070Spatrick EmitFinalDestCopy(E->getType(), Res);
232e5dd7070Spatrick }
233e5dd7070Spatrick };
234e5dd7070Spatrick } // end anonymous namespace.
235e5dd7070Spatrick
236e5dd7070Spatrick //===----------------------------------------------------------------------===//
237e5dd7070Spatrick // Utilities
238e5dd7070Spatrick //===----------------------------------------------------------------------===//
239e5dd7070Spatrick
240e5dd7070Spatrick /// EmitAggLoadOfLValue - Given an expression with aggregate type that
241e5dd7070Spatrick /// represents a value lvalue, this method emits the address of the lvalue,
242e5dd7070Spatrick /// then loads the result into DestPtr.
EmitAggLoadOfLValue(const Expr * E)243e5dd7070Spatrick void AggExprEmitter::EmitAggLoadOfLValue(const Expr *E) {
244e5dd7070Spatrick LValue LV = CGF.EmitLValue(E);
245e5dd7070Spatrick
246e5dd7070Spatrick // If the type of the l-value is atomic, then do an atomic load.
247e5dd7070Spatrick if (LV.getType()->isAtomicType() || CGF.LValueIsSuitableForInlineAtomic(LV)) {
248e5dd7070Spatrick CGF.EmitAtomicLoad(LV, E->getExprLoc(), Dest);
249e5dd7070Spatrick return;
250e5dd7070Spatrick }
251e5dd7070Spatrick
252e5dd7070Spatrick EmitFinalDestCopy(E->getType(), LV);
253e5dd7070Spatrick }
254e5dd7070Spatrick
255e5dd7070Spatrick /// True if the given aggregate type requires special GC API calls.
TypeRequiresGCollection(QualType T)256e5dd7070Spatrick bool AggExprEmitter::TypeRequiresGCollection(QualType T) {
257e5dd7070Spatrick // Only record types have members that might require garbage collection.
258e5dd7070Spatrick const RecordType *RecordTy = T->getAs<RecordType>();
259e5dd7070Spatrick if (!RecordTy) return false;
260e5dd7070Spatrick
261e5dd7070Spatrick // Don't mess with non-trivial C++ types.
262e5dd7070Spatrick RecordDecl *Record = RecordTy->getDecl();
263e5dd7070Spatrick if (isa<CXXRecordDecl>(Record) &&
264e5dd7070Spatrick (cast<CXXRecordDecl>(Record)->hasNonTrivialCopyConstructor() ||
265e5dd7070Spatrick !cast<CXXRecordDecl>(Record)->hasTrivialDestructor()))
266e5dd7070Spatrick return false;
267e5dd7070Spatrick
268e5dd7070Spatrick // Check whether the type has an object member.
269e5dd7070Spatrick return Record->hasObjectMember();
270e5dd7070Spatrick }
271e5dd7070Spatrick
withReturnValueSlot(const Expr * E,llvm::function_ref<RValue (ReturnValueSlot)> EmitCall)272e5dd7070Spatrick void AggExprEmitter::withReturnValueSlot(
273e5dd7070Spatrick const Expr *E, llvm::function_ref<RValue(ReturnValueSlot)> EmitCall) {
274e5dd7070Spatrick QualType RetTy = E->getType();
275e5dd7070Spatrick bool RequiresDestruction =
276ec727ea7Spatrick !Dest.isExternallyDestructed() &&
277e5dd7070Spatrick RetTy.isDestructedType() == QualType::DK_nontrivial_c_struct;
278e5dd7070Spatrick
279e5dd7070Spatrick // If it makes no observable difference, save a memcpy + temporary.
280e5dd7070Spatrick //
281e5dd7070Spatrick // We need to always provide our own temporary if destruction is required.
282e5dd7070Spatrick // Otherwise, EmitCall will emit its own, notice that it's "unused", and end
283e5dd7070Spatrick // its lifetime before we have the chance to emit a proper destructor call.
284e5dd7070Spatrick bool UseTemp = Dest.isPotentiallyAliased() || Dest.requiresGCollection() ||
285e5dd7070Spatrick (RequiresDestruction && !Dest.getAddress().isValid());
286e5dd7070Spatrick
287e5dd7070Spatrick Address RetAddr = Address::invalid();
288e5dd7070Spatrick Address RetAllocaAddr = Address::invalid();
289e5dd7070Spatrick
290e5dd7070Spatrick EHScopeStack::stable_iterator LifetimeEndBlock;
291e5dd7070Spatrick llvm::Value *LifetimeSizePtr = nullptr;
292e5dd7070Spatrick llvm::IntrinsicInst *LifetimeStartInst = nullptr;
293e5dd7070Spatrick if (!UseTemp) {
294e5dd7070Spatrick RetAddr = Dest.getAddress();
295e5dd7070Spatrick } else {
296e5dd7070Spatrick RetAddr = CGF.CreateMemTemp(RetTy, "tmp", &RetAllocaAddr);
297a9ac8606Spatrick llvm::TypeSize Size =
298e5dd7070Spatrick CGF.CGM.getDataLayout().getTypeAllocSize(CGF.ConvertTypeForMem(RetTy));
299e5dd7070Spatrick LifetimeSizePtr = CGF.EmitLifetimeStart(Size, RetAllocaAddr.getPointer());
300e5dd7070Spatrick if (LifetimeSizePtr) {
301e5dd7070Spatrick LifetimeStartInst =
302e5dd7070Spatrick cast<llvm::IntrinsicInst>(std::prev(Builder.GetInsertPoint()));
303e5dd7070Spatrick assert(LifetimeStartInst->getIntrinsicID() ==
304e5dd7070Spatrick llvm::Intrinsic::lifetime_start &&
305e5dd7070Spatrick "Last insertion wasn't a lifetime.start?");
306e5dd7070Spatrick
307e5dd7070Spatrick CGF.pushFullExprCleanup<CodeGenFunction::CallLifetimeEnd>(
308e5dd7070Spatrick NormalEHLifetimeMarker, RetAllocaAddr, LifetimeSizePtr);
309e5dd7070Spatrick LifetimeEndBlock = CGF.EHStack.stable_begin();
310e5dd7070Spatrick }
311e5dd7070Spatrick }
312e5dd7070Spatrick
313e5dd7070Spatrick RValue Src =
314ec727ea7Spatrick EmitCall(ReturnValueSlot(RetAddr, Dest.isVolatile(), IsResultUnused,
315ec727ea7Spatrick Dest.isExternallyDestructed()));
316e5dd7070Spatrick
317e5dd7070Spatrick if (!UseTemp)
318e5dd7070Spatrick return;
319e5dd7070Spatrick
320*12c85518Srobert assert(Dest.isIgnored() || Dest.getPointer() != Src.getAggregatePointer());
321e5dd7070Spatrick EmitFinalDestCopy(E->getType(), Src);
322e5dd7070Spatrick
323e5dd7070Spatrick if (!RequiresDestruction && LifetimeStartInst) {
324e5dd7070Spatrick // If there's no dtor to run, the copy was the last use of our temporary.
325e5dd7070Spatrick // Since we're not guaranteed to be in an ExprWithCleanups, clean up
326e5dd7070Spatrick // eagerly.
327e5dd7070Spatrick CGF.DeactivateCleanupBlock(LifetimeEndBlock, LifetimeStartInst);
328e5dd7070Spatrick CGF.EmitLifetimeEnd(LifetimeSizePtr, RetAllocaAddr.getPointer());
329e5dd7070Spatrick }
330e5dd7070Spatrick }
331e5dd7070Spatrick
332e5dd7070Spatrick /// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
EmitFinalDestCopy(QualType type,RValue src)333e5dd7070Spatrick void AggExprEmitter::EmitFinalDestCopy(QualType type, RValue src) {
334e5dd7070Spatrick assert(src.isAggregate() && "value must be aggregate value!");
335e5dd7070Spatrick LValue srcLV = CGF.MakeAddrLValue(src.getAggregateAddress(), type);
336e5dd7070Spatrick EmitFinalDestCopy(type, srcLV, EVK_RValue);
337e5dd7070Spatrick }
338e5dd7070Spatrick
339e5dd7070Spatrick /// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
EmitFinalDestCopy(QualType type,const LValue & src,ExprValueKind SrcValueKind)340e5dd7070Spatrick void AggExprEmitter::EmitFinalDestCopy(QualType type, const LValue &src,
341e5dd7070Spatrick ExprValueKind SrcValueKind) {
342e5dd7070Spatrick // If Dest is ignored, then we're evaluating an aggregate expression
343e5dd7070Spatrick // in a context that doesn't care about the result. Note that loads
344e5dd7070Spatrick // from volatile l-values force the existence of a non-ignored
345e5dd7070Spatrick // destination.
346e5dd7070Spatrick if (Dest.isIgnored())
347e5dd7070Spatrick return;
348e5dd7070Spatrick
349e5dd7070Spatrick // Copy non-trivial C structs here.
350e5dd7070Spatrick LValue DstLV = CGF.MakeAddrLValue(
351e5dd7070Spatrick Dest.getAddress(), Dest.isVolatile() ? type.withVolatile() : type);
352e5dd7070Spatrick
353e5dd7070Spatrick if (SrcValueKind == EVK_RValue) {
354e5dd7070Spatrick if (type.isNonTrivialToPrimitiveDestructiveMove() == QualType::PCK_Struct) {
355e5dd7070Spatrick if (Dest.isPotentiallyAliased())
356e5dd7070Spatrick CGF.callCStructMoveAssignmentOperator(DstLV, src);
357e5dd7070Spatrick else
358e5dd7070Spatrick CGF.callCStructMoveConstructor(DstLV, src);
359e5dd7070Spatrick return;
360e5dd7070Spatrick }
361e5dd7070Spatrick } else {
362e5dd7070Spatrick if (type.isNonTrivialToPrimitiveCopy() == QualType::PCK_Struct) {
363e5dd7070Spatrick if (Dest.isPotentiallyAliased())
364e5dd7070Spatrick CGF.callCStructCopyAssignmentOperator(DstLV, src);
365e5dd7070Spatrick else
366e5dd7070Spatrick CGF.callCStructCopyConstructor(DstLV, src);
367e5dd7070Spatrick return;
368e5dd7070Spatrick }
369e5dd7070Spatrick }
370e5dd7070Spatrick
371e5dd7070Spatrick AggValueSlot srcAgg = AggValueSlot::forLValue(
372e5dd7070Spatrick src, CGF, AggValueSlot::IsDestructed, needsGC(type),
373e5dd7070Spatrick AggValueSlot::IsAliased, AggValueSlot::MayOverlap);
374e5dd7070Spatrick EmitCopy(type, Dest, srcAgg);
375e5dd7070Spatrick }
376e5dd7070Spatrick
377e5dd7070Spatrick /// Perform a copy from the source into the destination.
378e5dd7070Spatrick ///
379e5dd7070Spatrick /// \param type - the type of the aggregate being copied; qualifiers are
380e5dd7070Spatrick /// ignored
EmitCopy(QualType type,const AggValueSlot & dest,const AggValueSlot & src)381e5dd7070Spatrick void AggExprEmitter::EmitCopy(QualType type, const AggValueSlot &dest,
382e5dd7070Spatrick const AggValueSlot &src) {
383e5dd7070Spatrick if (dest.requiresGCollection()) {
384e5dd7070Spatrick CharUnits sz = dest.getPreferredSize(CGF.getContext(), type);
385e5dd7070Spatrick llvm::Value *size = llvm::ConstantInt::get(CGF.SizeTy, sz.getQuantity());
386e5dd7070Spatrick CGF.CGM.getObjCRuntime().EmitGCMemmoveCollectable(CGF,
387e5dd7070Spatrick dest.getAddress(),
388e5dd7070Spatrick src.getAddress(),
389e5dd7070Spatrick size);
390e5dd7070Spatrick return;
391e5dd7070Spatrick }
392e5dd7070Spatrick
393e5dd7070Spatrick // If the result of the assignment is used, copy the LHS there also.
394e5dd7070Spatrick // It's volatile if either side is. Use the minimum alignment of
395e5dd7070Spatrick // the two sides.
396e5dd7070Spatrick LValue DestLV = CGF.MakeAddrLValue(dest.getAddress(), type);
397e5dd7070Spatrick LValue SrcLV = CGF.MakeAddrLValue(src.getAddress(), type);
398e5dd7070Spatrick CGF.EmitAggregateCopy(DestLV, SrcLV, type, dest.mayOverlap(),
399e5dd7070Spatrick dest.isVolatile() || src.isVolatile());
400e5dd7070Spatrick }
401e5dd7070Spatrick
402e5dd7070Spatrick /// Emit the initializer for a std::initializer_list initialized with a
403e5dd7070Spatrick /// real initializer list.
404e5dd7070Spatrick void
VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr * E)405e5dd7070Spatrick AggExprEmitter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
406e5dd7070Spatrick // Emit an array containing the elements. The array is externally destructed
407e5dd7070Spatrick // if the std::initializer_list object is.
408e5dd7070Spatrick ASTContext &Ctx = CGF.getContext();
409e5dd7070Spatrick LValue Array = CGF.EmitLValue(E->getSubExpr());
410e5dd7070Spatrick assert(Array.isSimple() && "initializer_list array not a simple lvalue");
411e5dd7070Spatrick Address ArrayPtr = Array.getAddress(CGF);
412e5dd7070Spatrick
413e5dd7070Spatrick const ConstantArrayType *ArrayType =
414e5dd7070Spatrick Ctx.getAsConstantArrayType(E->getSubExpr()->getType());
415e5dd7070Spatrick assert(ArrayType && "std::initializer_list constructed from non-array");
416e5dd7070Spatrick
417e5dd7070Spatrick // FIXME: Perform the checks on the field types in SemaInit.
418e5dd7070Spatrick RecordDecl *Record = E->getType()->castAs<RecordType>()->getDecl();
419e5dd7070Spatrick RecordDecl::field_iterator Field = Record->field_begin();
420e5dd7070Spatrick if (Field == Record->field_end()) {
421e5dd7070Spatrick CGF.ErrorUnsupported(E, "weird std::initializer_list");
422e5dd7070Spatrick return;
423e5dd7070Spatrick }
424e5dd7070Spatrick
425e5dd7070Spatrick // Start pointer.
426e5dd7070Spatrick if (!Field->getType()->isPointerType() ||
427e5dd7070Spatrick !Ctx.hasSameType(Field->getType()->getPointeeType(),
428e5dd7070Spatrick ArrayType->getElementType())) {
429e5dd7070Spatrick CGF.ErrorUnsupported(E, "weird std::initializer_list");
430e5dd7070Spatrick return;
431e5dd7070Spatrick }
432e5dd7070Spatrick
433e5dd7070Spatrick AggValueSlot Dest = EnsureSlot(E->getType());
434e5dd7070Spatrick LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType());
435e5dd7070Spatrick LValue Start = CGF.EmitLValueForFieldInitialization(DestLV, *Field);
436e5dd7070Spatrick llvm::Value *Zero = llvm::ConstantInt::get(CGF.PtrDiffTy, 0);
437e5dd7070Spatrick llvm::Value *IdxStart[] = { Zero, Zero };
438a9ac8606Spatrick llvm::Value *ArrayStart = Builder.CreateInBoundsGEP(
439a9ac8606Spatrick ArrayPtr.getElementType(), ArrayPtr.getPointer(), IdxStart, "arraystart");
440e5dd7070Spatrick CGF.EmitStoreThroughLValue(RValue::get(ArrayStart), Start);
441e5dd7070Spatrick ++Field;
442e5dd7070Spatrick
443e5dd7070Spatrick if (Field == Record->field_end()) {
444e5dd7070Spatrick CGF.ErrorUnsupported(E, "weird std::initializer_list");
445e5dd7070Spatrick return;
446e5dd7070Spatrick }
447e5dd7070Spatrick
448e5dd7070Spatrick llvm::Value *Size = Builder.getInt(ArrayType->getSize());
449e5dd7070Spatrick LValue EndOrLength = CGF.EmitLValueForFieldInitialization(DestLV, *Field);
450e5dd7070Spatrick if (Field->getType()->isPointerType() &&
451e5dd7070Spatrick Ctx.hasSameType(Field->getType()->getPointeeType(),
452e5dd7070Spatrick ArrayType->getElementType())) {
453e5dd7070Spatrick // End pointer.
454e5dd7070Spatrick llvm::Value *IdxEnd[] = { Zero, Size };
455a9ac8606Spatrick llvm::Value *ArrayEnd = Builder.CreateInBoundsGEP(
456a9ac8606Spatrick ArrayPtr.getElementType(), ArrayPtr.getPointer(), IdxEnd, "arrayend");
457e5dd7070Spatrick CGF.EmitStoreThroughLValue(RValue::get(ArrayEnd), EndOrLength);
458e5dd7070Spatrick } else if (Ctx.hasSameType(Field->getType(), Ctx.getSizeType())) {
459e5dd7070Spatrick // Length.
460e5dd7070Spatrick CGF.EmitStoreThroughLValue(RValue::get(Size), EndOrLength);
461e5dd7070Spatrick } else {
462e5dd7070Spatrick CGF.ErrorUnsupported(E, "weird std::initializer_list");
463e5dd7070Spatrick return;
464e5dd7070Spatrick }
465e5dd7070Spatrick }
466e5dd7070Spatrick
467e5dd7070Spatrick /// Determine if E is a trivial array filler, that is, one that is
468e5dd7070Spatrick /// equivalent to zero-initialization.
isTrivialFiller(Expr * E)469e5dd7070Spatrick static bool isTrivialFiller(Expr *E) {
470e5dd7070Spatrick if (!E)
471e5dd7070Spatrick return true;
472e5dd7070Spatrick
473e5dd7070Spatrick if (isa<ImplicitValueInitExpr>(E))
474e5dd7070Spatrick return true;
475e5dd7070Spatrick
476e5dd7070Spatrick if (auto *ILE = dyn_cast<InitListExpr>(E)) {
477e5dd7070Spatrick if (ILE->getNumInits())
478e5dd7070Spatrick return false;
479e5dd7070Spatrick return isTrivialFiller(ILE->getArrayFiller());
480e5dd7070Spatrick }
481e5dd7070Spatrick
482e5dd7070Spatrick if (auto *Cons = dyn_cast_or_null<CXXConstructExpr>(E))
483e5dd7070Spatrick return Cons->getConstructor()->isDefaultConstructor() &&
484e5dd7070Spatrick Cons->getConstructor()->isTrivial();
485e5dd7070Spatrick
486e5dd7070Spatrick // FIXME: Are there other cases where we can avoid emitting an initializer?
487e5dd7070Spatrick return false;
488e5dd7070Spatrick }
489e5dd7070Spatrick
490*12c85518Srobert /// Emit initialization of an array from an initializer list. ExprToVisit must
491*12c85518Srobert /// be either an InitListEpxr a CXXParenInitListExpr.
EmitArrayInit(Address DestPtr,llvm::ArrayType * AType,QualType ArrayQTy,Expr * ExprToVisit,ArrayRef<Expr * > Args,Expr * ArrayFiller)492e5dd7070Spatrick void AggExprEmitter::EmitArrayInit(Address DestPtr, llvm::ArrayType *AType,
493*12c85518Srobert QualType ArrayQTy, Expr *ExprToVisit,
494*12c85518Srobert ArrayRef<Expr *> Args, Expr *ArrayFiller) {
495*12c85518Srobert uint64_t NumInitElements = Args.size();
496e5dd7070Spatrick
497e5dd7070Spatrick uint64_t NumArrayElements = AType->getNumElements();
498e5dd7070Spatrick assert(NumInitElements <= NumArrayElements);
499e5dd7070Spatrick
500e5dd7070Spatrick QualType elementType =
501e5dd7070Spatrick CGF.getContext().getAsArrayType(ArrayQTy)->getElementType();
502e5dd7070Spatrick
503e5dd7070Spatrick // DestPtr is an array*. Construct an elementType* by drilling
504e5dd7070Spatrick // down a level.
505e5dd7070Spatrick llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, 0);
506e5dd7070Spatrick llvm::Value *indices[] = { zero, zero };
507a9ac8606Spatrick llvm::Value *begin = Builder.CreateInBoundsGEP(
508a9ac8606Spatrick DestPtr.getElementType(), DestPtr.getPointer(), indices,
509a9ac8606Spatrick "arrayinit.begin");
510e5dd7070Spatrick
511e5dd7070Spatrick CharUnits elementSize = CGF.getContext().getTypeSizeInChars(elementType);
512e5dd7070Spatrick CharUnits elementAlign =
513e5dd7070Spatrick DestPtr.getAlignment().alignmentOfArrayElement(elementSize);
514*12c85518Srobert llvm::Type *llvmElementType = CGF.ConvertTypeForMem(elementType);
515e5dd7070Spatrick
516e5dd7070Spatrick // Consider initializing the array by copying from a global. For this to be
517e5dd7070Spatrick // more efficient than per-element initialization, the size of the elements
518e5dd7070Spatrick // with explicit initializers should be large enough.
519e5dd7070Spatrick if (NumInitElements * elementSize.getQuantity() > 16 &&
520e5dd7070Spatrick elementType.isTriviallyCopyableType(CGF.getContext())) {
521e5dd7070Spatrick CodeGen::CodeGenModule &CGM = CGF.CGM;
522e5dd7070Spatrick ConstantEmitter Emitter(CGF);
523e5dd7070Spatrick LangAS AS = ArrayQTy.getAddressSpace();
524*12c85518Srobert if (llvm::Constant *C =
525*12c85518Srobert Emitter.tryEmitForInitializer(ExprToVisit, AS, ArrayQTy)) {
526e5dd7070Spatrick auto GV = new llvm::GlobalVariable(
527e5dd7070Spatrick CGM.getModule(), C->getType(),
528e5dd7070Spatrick CGM.isTypeConstant(ArrayQTy, /* ExcludeCtorDtor= */ true),
529e5dd7070Spatrick llvm::GlobalValue::PrivateLinkage, C, "constinit",
530e5dd7070Spatrick /* InsertBefore= */ nullptr, llvm::GlobalVariable::NotThreadLocal,
531e5dd7070Spatrick CGM.getContext().getTargetAddressSpace(AS));
532e5dd7070Spatrick Emitter.finalize(GV);
533e5dd7070Spatrick CharUnits Align = CGM.getContext().getTypeAlignInChars(ArrayQTy);
534e5dd7070Spatrick GV->setAlignment(Align.getAsAlign());
535*12c85518Srobert Address GVAddr(GV, GV->getValueType(), Align);
536*12c85518Srobert EmitFinalDestCopy(ArrayQTy, CGF.MakeAddrLValue(GVAddr, ArrayQTy));
537e5dd7070Spatrick return;
538e5dd7070Spatrick }
539e5dd7070Spatrick }
540e5dd7070Spatrick
541e5dd7070Spatrick // Exception safety requires us to destroy all the
542e5dd7070Spatrick // already-constructed members if an initializer throws.
543e5dd7070Spatrick // For that, we'll need an EH cleanup.
544e5dd7070Spatrick QualType::DestructionKind dtorKind = elementType.isDestructedType();
545e5dd7070Spatrick Address endOfInit = Address::invalid();
546e5dd7070Spatrick EHScopeStack::stable_iterator cleanup;
547e5dd7070Spatrick llvm::Instruction *cleanupDominator = nullptr;
548e5dd7070Spatrick if (CGF.needsEHCleanup(dtorKind)) {
549e5dd7070Spatrick // In principle we could tell the cleanup where we are more
550e5dd7070Spatrick // directly, but the control flow can get so varied here that it
551e5dd7070Spatrick // would actually be quite complex. Therefore we go through an
552e5dd7070Spatrick // alloca.
553e5dd7070Spatrick endOfInit = CGF.CreateTempAlloca(begin->getType(), CGF.getPointerAlign(),
554e5dd7070Spatrick "arrayinit.endOfInit");
555e5dd7070Spatrick cleanupDominator = Builder.CreateStore(begin, endOfInit);
556e5dd7070Spatrick CGF.pushIrregularPartialArrayCleanup(begin, endOfInit, elementType,
557e5dd7070Spatrick elementAlign,
558e5dd7070Spatrick CGF.getDestroyer(dtorKind));
559e5dd7070Spatrick cleanup = CGF.EHStack.stable_begin();
560e5dd7070Spatrick
561e5dd7070Spatrick // Otherwise, remember that we didn't need a cleanup.
562e5dd7070Spatrick } else {
563e5dd7070Spatrick dtorKind = QualType::DK_none;
564e5dd7070Spatrick }
565e5dd7070Spatrick
566e5dd7070Spatrick llvm::Value *one = llvm::ConstantInt::get(CGF.SizeTy, 1);
567e5dd7070Spatrick
568e5dd7070Spatrick // The 'current element to initialize'. The invariants on this
569e5dd7070Spatrick // variable are complicated. Essentially, after each iteration of
570e5dd7070Spatrick // the loop, it points to the last initialized element, except
571e5dd7070Spatrick // that it points to the beginning of the array before any
572e5dd7070Spatrick // elements have been initialized.
573e5dd7070Spatrick llvm::Value *element = begin;
574e5dd7070Spatrick
575e5dd7070Spatrick // Emit the explicit initializers.
576e5dd7070Spatrick for (uint64_t i = 0; i != NumInitElements; ++i) {
577e5dd7070Spatrick // Advance to the next element.
578e5dd7070Spatrick if (i > 0) {
579a9ac8606Spatrick element = Builder.CreateInBoundsGEP(
580a9ac8606Spatrick llvmElementType, element, one, "arrayinit.element");
581e5dd7070Spatrick
582e5dd7070Spatrick // Tell the cleanup that it needs to destroy up to this
583e5dd7070Spatrick // element. TODO: some of these stores can be trivially
584e5dd7070Spatrick // observed to be unnecessary.
585e5dd7070Spatrick if (endOfInit.isValid()) Builder.CreateStore(element, endOfInit);
586e5dd7070Spatrick }
587e5dd7070Spatrick
588*12c85518Srobert LValue elementLV = CGF.MakeAddrLValue(
589*12c85518Srobert Address(element, llvmElementType, elementAlign), elementType);
590*12c85518Srobert EmitInitializationToLValue(Args[i], elementLV);
591e5dd7070Spatrick }
592e5dd7070Spatrick
593e5dd7070Spatrick // Check whether there's a non-trivial array-fill expression.
594*12c85518Srobert bool hasTrivialFiller = isTrivialFiller(ArrayFiller);
595e5dd7070Spatrick
596e5dd7070Spatrick // Any remaining elements need to be zero-initialized, possibly
597e5dd7070Spatrick // using the filler expression. We can skip this if the we're
598e5dd7070Spatrick // emitting to zeroed memory.
599e5dd7070Spatrick if (NumInitElements != NumArrayElements &&
600e5dd7070Spatrick !(Dest.isZeroed() && hasTrivialFiller &&
601e5dd7070Spatrick CGF.getTypes().isZeroInitializable(elementType))) {
602e5dd7070Spatrick
603e5dd7070Spatrick // Use an actual loop. This is basically
604e5dd7070Spatrick // do { *array++ = filler; } while (array != end);
605e5dd7070Spatrick
606e5dd7070Spatrick // Advance to the start of the rest of the array.
607e5dd7070Spatrick if (NumInitElements) {
608a9ac8606Spatrick element = Builder.CreateInBoundsGEP(
609a9ac8606Spatrick llvmElementType, element, one, "arrayinit.start");
610e5dd7070Spatrick if (endOfInit.isValid()) Builder.CreateStore(element, endOfInit);
611e5dd7070Spatrick }
612e5dd7070Spatrick
613e5dd7070Spatrick // Compute the end of the array.
614a9ac8606Spatrick llvm::Value *end = Builder.CreateInBoundsGEP(
615a9ac8606Spatrick llvmElementType, begin,
616a9ac8606Spatrick llvm::ConstantInt::get(CGF.SizeTy, NumArrayElements), "arrayinit.end");
617e5dd7070Spatrick
618e5dd7070Spatrick llvm::BasicBlock *entryBB = Builder.GetInsertBlock();
619e5dd7070Spatrick llvm::BasicBlock *bodyBB = CGF.createBasicBlock("arrayinit.body");
620e5dd7070Spatrick
621e5dd7070Spatrick // Jump into the body.
622e5dd7070Spatrick CGF.EmitBlock(bodyBB);
623e5dd7070Spatrick llvm::PHINode *currentElement =
624e5dd7070Spatrick Builder.CreatePHI(element->getType(), 2, "arrayinit.cur");
625e5dd7070Spatrick currentElement->addIncoming(element, entryBB);
626e5dd7070Spatrick
627e5dd7070Spatrick // Emit the actual filler expression.
628e5dd7070Spatrick {
629e5dd7070Spatrick // C++1z [class.temporary]p5:
630e5dd7070Spatrick // when a default constructor is called to initialize an element of
631e5dd7070Spatrick // an array with no corresponding initializer [...] the destruction of
632e5dd7070Spatrick // every temporary created in a default argument is sequenced before
633e5dd7070Spatrick // the construction of the next array element, if any
634e5dd7070Spatrick CodeGenFunction::RunCleanupsScope CleanupsScope(CGF);
635*12c85518Srobert LValue elementLV = CGF.MakeAddrLValue(
636*12c85518Srobert Address(currentElement, llvmElementType, elementAlign), elementType);
637*12c85518Srobert if (ArrayFiller)
638*12c85518Srobert EmitInitializationToLValue(ArrayFiller, elementLV);
639e5dd7070Spatrick else
640e5dd7070Spatrick EmitNullInitializationToLValue(elementLV);
641e5dd7070Spatrick }
642e5dd7070Spatrick
643e5dd7070Spatrick // Move on to the next element.
644a9ac8606Spatrick llvm::Value *nextElement = Builder.CreateInBoundsGEP(
645a9ac8606Spatrick llvmElementType, currentElement, one, "arrayinit.next");
646e5dd7070Spatrick
647e5dd7070Spatrick // Tell the EH cleanup that we finished with the last element.
648e5dd7070Spatrick if (endOfInit.isValid()) Builder.CreateStore(nextElement, endOfInit);
649e5dd7070Spatrick
650e5dd7070Spatrick // Leave the loop if we're done.
651e5dd7070Spatrick llvm::Value *done = Builder.CreateICmpEQ(nextElement, end,
652e5dd7070Spatrick "arrayinit.done");
653e5dd7070Spatrick llvm::BasicBlock *endBB = CGF.createBasicBlock("arrayinit.end");
654e5dd7070Spatrick Builder.CreateCondBr(done, endBB, bodyBB);
655e5dd7070Spatrick currentElement->addIncoming(nextElement, Builder.GetInsertBlock());
656e5dd7070Spatrick
657e5dd7070Spatrick CGF.EmitBlock(endBB);
658e5dd7070Spatrick }
659e5dd7070Spatrick
660e5dd7070Spatrick // Leave the partial-array cleanup if we entered one.
661e5dd7070Spatrick if (dtorKind) CGF.DeactivateCleanupBlock(cleanup, cleanupDominator);
662e5dd7070Spatrick }
663e5dd7070Spatrick
664e5dd7070Spatrick //===----------------------------------------------------------------------===//
665e5dd7070Spatrick // Visitor Methods
666e5dd7070Spatrick //===----------------------------------------------------------------------===//
667e5dd7070Spatrick
VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr * E)668e5dd7070Spatrick void AggExprEmitter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E){
669e5dd7070Spatrick Visit(E->getSubExpr());
670e5dd7070Spatrick }
671e5dd7070Spatrick
VisitOpaqueValueExpr(OpaqueValueExpr * e)672e5dd7070Spatrick void AggExprEmitter::VisitOpaqueValueExpr(OpaqueValueExpr *e) {
673e5dd7070Spatrick // If this is a unique OVE, just visit its source expression.
674e5dd7070Spatrick if (e->isUnique())
675e5dd7070Spatrick Visit(e->getSourceExpr());
676e5dd7070Spatrick else
677e5dd7070Spatrick EmitFinalDestCopy(e->getType(), CGF.getOrCreateOpaqueLValueMapping(e));
678e5dd7070Spatrick }
679e5dd7070Spatrick
680e5dd7070Spatrick void
VisitCompoundLiteralExpr(CompoundLiteralExpr * E)681e5dd7070Spatrick AggExprEmitter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
682e5dd7070Spatrick if (Dest.isPotentiallyAliased() &&
683e5dd7070Spatrick E->getType().isPODType(CGF.getContext())) {
684e5dd7070Spatrick // For a POD type, just emit a load of the lvalue + a copy, because our
685e5dd7070Spatrick // compound literal might alias the destination.
686e5dd7070Spatrick EmitAggLoadOfLValue(E);
687e5dd7070Spatrick return;
688e5dd7070Spatrick }
689e5dd7070Spatrick
690e5dd7070Spatrick AggValueSlot Slot = EnsureSlot(E->getType());
691ec727ea7Spatrick
692ec727ea7Spatrick // Block-scope compound literals are destroyed at the end of the enclosing
693ec727ea7Spatrick // scope in C.
694ec727ea7Spatrick bool Destruct =
695ec727ea7Spatrick !CGF.getLangOpts().CPlusPlus && !Slot.isExternallyDestructed();
696ec727ea7Spatrick if (Destruct)
697ec727ea7Spatrick Slot.setExternallyDestructed();
698ec727ea7Spatrick
699e5dd7070Spatrick CGF.EmitAggExpr(E->getInitializer(), Slot);
700ec727ea7Spatrick
701ec727ea7Spatrick if (Destruct)
702ec727ea7Spatrick if (QualType::DestructionKind DtorKind = E->getType().isDestructedType())
703ec727ea7Spatrick CGF.pushLifetimeExtendedDestroy(
704ec727ea7Spatrick CGF.getCleanupKind(DtorKind), Slot.getAddress(), E->getType(),
705ec727ea7Spatrick CGF.getDestroyer(DtorKind), DtorKind & EHCleanup);
706e5dd7070Spatrick }
707e5dd7070Spatrick
708e5dd7070Spatrick /// Attempt to look through various unimportant expressions to find a
709e5dd7070Spatrick /// cast of the given kind.
findPeephole(Expr * op,CastKind kind,const ASTContext & ctx)710ec727ea7Spatrick static Expr *findPeephole(Expr *op, CastKind kind, const ASTContext &ctx) {
711ec727ea7Spatrick op = op->IgnoreParenNoopCasts(ctx);
712ec727ea7Spatrick if (auto castE = dyn_cast<CastExpr>(op)) {
713e5dd7070Spatrick if (castE->getCastKind() == kind)
714e5dd7070Spatrick return castE->getSubExpr();
715e5dd7070Spatrick }
716e5dd7070Spatrick return nullptr;
717e5dd7070Spatrick }
718e5dd7070Spatrick
VisitCastExpr(CastExpr * E)719e5dd7070Spatrick void AggExprEmitter::VisitCastExpr(CastExpr *E) {
720e5dd7070Spatrick if (const auto *ECE = dyn_cast<ExplicitCastExpr>(E))
721e5dd7070Spatrick CGF.CGM.EmitExplicitCastExprType(ECE, &CGF);
722e5dd7070Spatrick switch (E->getCastKind()) {
723e5dd7070Spatrick case CK_Dynamic: {
724e5dd7070Spatrick // FIXME: Can this actually happen? We have no test coverage for it.
725e5dd7070Spatrick assert(isa<CXXDynamicCastExpr>(E) && "CK_Dynamic without a dynamic_cast?");
726e5dd7070Spatrick LValue LV = CGF.EmitCheckedLValue(E->getSubExpr(),
727e5dd7070Spatrick CodeGenFunction::TCK_Load);
728e5dd7070Spatrick // FIXME: Do we also need to handle property references here?
729e5dd7070Spatrick if (LV.isSimple())
730e5dd7070Spatrick CGF.EmitDynamicCast(LV.getAddress(CGF), cast<CXXDynamicCastExpr>(E));
731e5dd7070Spatrick else
732e5dd7070Spatrick CGF.CGM.ErrorUnsupported(E, "non-simple lvalue dynamic_cast");
733e5dd7070Spatrick
734e5dd7070Spatrick if (!Dest.isIgnored())
735e5dd7070Spatrick CGF.CGM.ErrorUnsupported(E, "lvalue dynamic_cast with a destination");
736e5dd7070Spatrick break;
737e5dd7070Spatrick }
738e5dd7070Spatrick
739e5dd7070Spatrick case CK_ToUnion: {
740e5dd7070Spatrick // Evaluate even if the destination is ignored.
741e5dd7070Spatrick if (Dest.isIgnored()) {
742e5dd7070Spatrick CGF.EmitAnyExpr(E->getSubExpr(), AggValueSlot::ignored(),
743e5dd7070Spatrick /*ignoreResult=*/true);
744e5dd7070Spatrick break;
745e5dd7070Spatrick }
746e5dd7070Spatrick
747e5dd7070Spatrick // GCC union extension
748e5dd7070Spatrick QualType Ty = E->getSubExpr()->getType();
749e5dd7070Spatrick Address CastPtr =
750e5dd7070Spatrick Builder.CreateElementBitCast(Dest.getAddress(), CGF.ConvertType(Ty));
751e5dd7070Spatrick EmitInitializationToLValue(E->getSubExpr(),
752e5dd7070Spatrick CGF.MakeAddrLValue(CastPtr, Ty));
753e5dd7070Spatrick break;
754e5dd7070Spatrick }
755e5dd7070Spatrick
756e5dd7070Spatrick case CK_LValueToRValueBitCast: {
757e5dd7070Spatrick if (Dest.isIgnored()) {
758e5dd7070Spatrick CGF.EmitAnyExpr(E->getSubExpr(), AggValueSlot::ignored(),
759e5dd7070Spatrick /*ignoreResult=*/true);
760e5dd7070Spatrick break;
761e5dd7070Spatrick }
762e5dd7070Spatrick
763e5dd7070Spatrick LValue SourceLV = CGF.EmitLValue(E->getSubExpr());
764e5dd7070Spatrick Address SourceAddress =
765e5dd7070Spatrick Builder.CreateElementBitCast(SourceLV.getAddress(CGF), CGF.Int8Ty);
766e5dd7070Spatrick Address DestAddress =
767e5dd7070Spatrick Builder.CreateElementBitCast(Dest.getAddress(), CGF.Int8Ty);
768e5dd7070Spatrick llvm::Value *SizeVal = llvm::ConstantInt::get(
769e5dd7070Spatrick CGF.SizeTy,
770e5dd7070Spatrick CGF.getContext().getTypeSizeInChars(E->getType()).getQuantity());
771e5dd7070Spatrick Builder.CreateMemCpy(DestAddress, SourceAddress, SizeVal);
772e5dd7070Spatrick break;
773e5dd7070Spatrick }
774e5dd7070Spatrick
775e5dd7070Spatrick case CK_DerivedToBase:
776e5dd7070Spatrick case CK_BaseToDerived:
777e5dd7070Spatrick case CK_UncheckedDerivedToBase: {
778e5dd7070Spatrick llvm_unreachable("cannot perform hierarchy conversion in EmitAggExpr: "
779e5dd7070Spatrick "should have been unpacked before we got here");
780e5dd7070Spatrick }
781e5dd7070Spatrick
782e5dd7070Spatrick case CK_NonAtomicToAtomic:
783e5dd7070Spatrick case CK_AtomicToNonAtomic: {
784e5dd7070Spatrick bool isToAtomic = (E->getCastKind() == CK_NonAtomicToAtomic);
785e5dd7070Spatrick
786e5dd7070Spatrick // Determine the atomic and value types.
787e5dd7070Spatrick QualType atomicType = E->getSubExpr()->getType();
788e5dd7070Spatrick QualType valueType = E->getType();
789e5dd7070Spatrick if (isToAtomic) std::swap(atomicType, valueType);
790e5dd7070Spatrick
791e5dd7070Spatrick assert(atomicType->isAtomicType());
792e5dd7070Spatrick assert(CGF.getContext().hasSameUnqualifiedType(valueType,
793e5dd7070Spatrick atomicType->castAs<AtomicType>()->getValueType()));
794e5dd7070Spatrick
795e5dd7070Spatrick // Just recurse normally if we're ignoring the result or the
796e5dd7070Spatrick // atomic type doesn't change representation.
797e5dd7070Spatrick if (Dest.isIgnored() || !CGF.CGM.isPaddedAtomicType(atomicType)) {
798e5dd7070Spatrick return Visit(E->getSubExpr());
799e5dd7070Spatrick }
800e5dd7070Spatrick
801e5dd7070Spatrick CastKind peepholeTarget =
802e5dd7070Spatrick (isToAtomic ? CK_AtomicToNonAtomic : CK_NonAtomicToAtomic);
803e5dd7070Spatrick
804e5dd7070Spatrick // These two cases are reverses of each other; try to peephole them.
805ec727ea7Spatrick if (Expr *op =
806ec727ea7Spatrick findPeephole(E->getSubExpr(), peepholeTarget, CGF.getContext())) {
807e5dd7070Spatrick assert(CGF.getContext().hasSameUnqualifiedType(op->getType(),
808e5dd7070Spatrick E->getType()) &&
809e5dd7070Spatrick "peephole significantly changed types?");
810e5dd7070Spatrick return Visit(op);
811e5dd7070Spatrick }
812e5dd7070Spatrick
813e5dd7070Spatrick // If we're converting an r-value of non-atomic type to an r-value
814e5dd7070Spatrick // of atomic type, just emit directly into the relevant sub-object.
815e5dd7070Spatrick if (isToAtomic) {
816e5dd7070Spatrick AggValueSlot valueDest = Dest;
817e5dd7070Spatrick if (!valueDest.isIgnored() && CGF.CGM.isPaddedAtomicType(atomicType)) {
818e5dd7070Spatrick // Zero-initialize. (Strictly speaking, we only need to initialize
819e5dd7070Spatrick // the padding at the end, but this is simpler.)
820e5dd7070Spatrick if (!Dest.isZeroed())
821e5dd7070Spatrick CGF.EmitNullInitialization(Dest.getAddress(), atomicType);
822e5dd7070Spatrick
823e5dd7070Spatrick // Build a GEP to refer to the subobject.
824e5dd7070Spatrick Address valueAddr =
825e5dd7070Spatrick CGF.Builder.CreateStructGEP(valueDest.getAddress(), 0);
826e5dd7070Spatrick valueDest = AggValueSlot::forAddr(valueAddr,
827e5dd7070Spatrick valueDest.getQualifiers(),
828e5dd7070Spatrick valueDest.isExternallyDestructed(),
829e5dd7070Spatrick valueDest.requiresGCollection(),
830e5dd7070Spatrick valueDest.isPotentiallyAliased(),
831e5dd7070Spatrick AggValueSlot::DoesNotOverlap,
832e5dd7070Spatrick AggValueSlot::IsZeroed);
833e5dd7070Spatrick }
834e5dd7070Spatrick
835e5dd7070Spatrick CGF.EmitAggExpr(E->getSubExpr(), valueDest);
836e5dd7070Spatrick return;
837e5dd7070Spatrick }
838e5dd7070Spatrick
839e5dd7070Spatrick // Otherwise, we're converting an atomic type to a non-atomic type.
840e5dd7070Spatrick // Make an atomic temporary, emit into that, and then copy the value out.
841e5dd7070Spatrick AggValueSlot atomicSlot =
842e5dd7070Spatrick CGF.CreateAggTemp(atomicType, "atomic-to-nonatomic.temp");
843e5dd7070Spatrick CGF.EmitAggExpr(E->getSubExpr(), atomicSlot);
844e5dd7070Spatrick
845e5dd7070Spatrick Address valueAddr = Builder.CreateStructGEP(atomicSlot.getAddress(), 0);
846e5dd7070Spatrick RValue rvalue = RValue::getAggregate(valueAddr, atomicSlot.isVolatile());
847e5dd7070Spatrick return EmitFinalDestCopy(valueType, rvalue);
848e5dd7070Spatrick }
849e5dd7070Spatrick case CK_AddressSpaceConversion:
850e5dd7070Spatrick return Visit(E->getSubExpr());
851e5dd7070Spatrick
852e5dd7070Spatrick case CK_LValueToRValue:
853e5dd7070Spatrick // If we're loading from a volatile type, force the destination
854e5dd7070Spatrick // into existence.
855e5dd7070Spatrick if (E->getSubExpr()->getType().isVolatileQualified()) {
856ec727ea7Spatrick bool Destruct =
857ec727ea7Spatrick !Dest.isExternallyDestructed() &&
858ec727ea7Spatrick E->getType().isDestructedType() == QualType::DK_nontrivial_c_struct;
859ec727ea7Spatrick if (Destruct)
860ec727ea7Spatrick Dest.setExternallyDestructed();
861e5dd7070Spatrick EnsureDest(E->getType());
862ec727ea7Spatrick Visit(E->getSubExpr());
863ec727ea7Spatrick
864ec727ea7Spatrick if (Destruct)
865ec727ea7Spatrick CGF.pushDestroy(QualType::DK_nontrivial_c_struct, Dest.getAddress(),
866ec727ea7Spatrick E->getType());
867ec727ea7Spatrick
868ec727ea7Spatrick return;
869e5dd7070Spatrick }
870e5dd7070Spatrick
871*12c85518Srobert [[fallthrough]];
872e5dd7070Spatrick
873e5dd7070Spatrick
874e5dd7070Spatrick case CK_NoOp:
875e5dd7070Spatrick case CK_UserDefinedConversion:
876e5dd7070Spatrick case CK_ConstructorConversion:
877e5dd7070Spatrick assert(CGF.getContext().hasSameUnqualifiedType(E->getSubExpr()->getType(),
878e5dd7070Spatrick E->getType()) &&
879e5dd7070Spatrick "Implicit cast types must be compatible");
880e5dd7070Spatrick Visit(E->getSubExpr());
881e5dd7070Spatrick break;
882e5dd7070Spatrick
883e5dd7070Spatrick case CK_LValueBitCast:
884e5dd7070Spatrick llvm_unreachable("should not be emitting lvalue bitcast as rvalue");
885e5dd7070Spatrick
886e5dd7070Spatrick case CK_Dependent:
887e5dd7070Spatrick case CK_BitCast:
888e5dd7070Spatrick case CK_ArrayToPointerDecay:
889e5dd7070Spatrick case CK_FunctionToPointerDecay:
890e5dd7070Spatrick case CK_NullToPointer:
891e5dd7070Spatrick case CK_NullToMemberPointer:
892e5dd7070Spatrick case CK_BaseToDerivedMemberPointer:
893e5dd7070Spatrick case CK_DerivedToBaseMemberPointer:
894e5dd7070Spatrick case CK_MemberPointerToBoolean:
895e5dd7070Spatrick case CK_ReinterpretMemberPointer:
896e5dd7070Spatrick case CK_IntegralToPointer:
897e5dd7070Spatrick case CK_PointerToIntegral:
898e5dd7070Spatrick case CK_PointerToBoolean:
899e5dd7070Spatrick case CK_ToVoid:
900e5dd7070Spatrick case CK_VectorSplat:
901e5dd7070Spatrick case CK_IntegralCast:
902e5dd7070Spatrick case CK_BooleanToSignedIntegral:
903e5dd7070Spatrick case CK_IntegralToBoolean:
904e5dd7070Spatrick case CK_IntegralToFloating:
905e5dd7070Spatrick case CK_FloatingToIntegral:
906e5dd7070Spatrick case CK_FloatingToBoolean:
907e5dd7070Spatrick case CK_FloatingCast:
908e5dd7070Spatrick case CK_CPointerToObjCPointerCast:
909e5dd7070Spatrick case CK_BlockPointerToObjCPointerCast:
910e5dd7070Spatrick case CK_AnyPointerToBlockPointerCast:
911e5dd7070Spatrick case CK_ObjCObjectLValueCast:
912e5dd7070Spatrick case CK_FloatingRealToComplex:
913e5dd7070Spatrick case CK_FloatingComplexToReal:
914e5dd7070Spatrick case CK_FloatingComplexToBoolean:
915e5dd7070Spatrick case CK_FloatingComplexCast:
916e5dd7070Spatrick case CK_FloatingComplexToIntegralComplex:
917e5dd7070Spatrick case CK_IntegralRealToComplex:
918e5dd7070Spatrick case CK_IntegralComplexToReal:
919e5dd7070Spatrick case CK_IntegralComplexToBoolean:
920e5dd7070Spatrick case CK_IntegralComplexCast:
921e5dd7070Spatrick case CK_IntegralComplexToFloatingComplex:
922e5dd7070Spatrick case CK_ARCProduceObject:
923e5dd7070Spatrick case CK_ARCConsumeObject:
924e5dd7070Spatrick case CK_ARCReclaimReturnedObject:
925e5dd7070Spatrick case CK_ARCExtendBlockObject:
926e5dd7070Spatrick case CK_CopyAndAutoreleaseBlockObject:
927e5dd7070Spatrick case CK_BuiltinFnToFnPtr:
928e5dd7070Spatrick case CK_ZeroToOCLOpaqueType:
929a9ac8606Spatrick case CK_MatrixCast:
930e5dd7070Spatrick
931e5dd7070Spatrick case CK_IntToOCLSampler:
932a9ac8606Spatrick case CK_FloatingToFixedPoint:
933a9ac8606Spatrick case CK_FixedPointToFloating:
934e5dd7070Spatrick case CK_FixedPointCast:
935e5dd7070Spatrick case CK_FixedPointToBoolean:
936e5dd7070Spatrick case CK_FixedPointToIntegral:
937e5dd7070Spatrick case CK_IntegralToFixedPoint:
938e5dd7070Spatrick llvm_unreachable("cast kind invalid for aggregate types");
939e5dd7070Spatrick }
940e5dd7070Spatrick }
941e5dd7070Spatrick
VisitCallExpr(const CallExpr * E)942e5dd7070Spatrick void AggExprEmitter::VisitCallExpr(const CallExpr *E) {
943e5dd7070Spatrick if (E->getCallReturnType(CGF.getContext())->isReferenceType()) {
944e5dd7070Spatrick EmitAggLoadOfLValue(E);
945e5dd7070Spatrick return;
946e5dd7070Spatrick }
947e5dd7070Spatrick
948e5dd7070Spatrick withReturnValueSlot(E, [&](ReturnValueSlot Slot) {
949e5dd7070Spatrick return CGF.EmitCallExpr(E, Slot);
950e5dd7070Spatrick });
951e5dd7070Spatrick }
952e5dd7070Spatrick
VisitObjCMessageExpr(ObjCMessageExpr * E)953e5dd7070Spatrick void AggExprEmitter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
954e5dd7070Spatrick withReturnValueSlot(E, [&](ReturnValueSlot Slot) {
955e5dd7070Spatrick return CGF.EmitObjCMessageExpr(E, Slot);
956e5dd7070Spatrick });
957e5dd7070Spatrick }
958e5dd7070Spatrick
VisitBinComma(const BinaryOperator * E)959e5dd7070Spatrick void AggExprEmitter::VisitBinComma(const BinaryOperator *E) {
960e5dd7070Spatrick CGF.EmitIgnoredExpr(E->getLHS());
961e5dd7070Spatrick Visit(E->getRHS());
962e5dd7070Spatrick }
963e5dd7070Spatrick
VisitStmtExpr(const StmtExpr * E)964e5dd7070Spatrick void AggExprEmitter::VisitStmtExpr(const StmtExpr *E) {
965e5dd7070Spatrick CodeGenFunction::StmtExprEvaluation eval(CGF);
966e5dd7070Spatrick CGF.EmitCompoundStmt(*E->getSubStmt(), true, Dest);
967e5dd7070Spatrick }
968e5dd7070Spatrick
969e5dd7070Spatrick enum CompareKind {
970e5dd7070Spatrick CK_Less,
971e5dd7070Spatrick CK_Greater,
972e5dd7070Spatrick CK_Equal,
973e5dd7070Spatrick };
974e5dd7070Spatrick
EmitCompare(CGBuilderTy & Builder,CodeGenFunction & CGF,const BinaryOperator * E,llvm::Value * LHS,llvm::Value * RHS,CompareKind Kind,const char * NameSuffix="")975e5dd7070Spatrick static llvm::Value *EmitCompare(CGBuilderTy &Builder, CodeGenFunction &CGF,
976e5dd7070Spatrick const BinaryOperator *E, llvm::Value *LHS,
977e5dd7070Spatrick llvm::Value *RHS, CompareKind Kind,
978e5dd7070Spatrick const char *NameSuffix = "") {
979e5dd7070Spatrick QualType ArgTy = E->getLHS()->getType();
980e5dd7070Spatrick if (const ComplexType *CT = ArgTy->getAs<ComplexType>())
981e5dd7070Spatrick ArgTy = CT->getElementType();
982e5dd7070Spatrick
983e5dd7070Spatrick if (const auto *MPT = ArgTy->getAs<MemberPointerType>()) {
984e5dd7070Spatrick assert(Kind == CK_Equal &&
985e5dd7070Spatrick "member pointers may only be compared for equality");
986e5dd7070Spatrick return CGF.CGM.getCXXABI().EmitMemberPointerComparison(
987e5dd7070Spatrick CGF, LHS, RHS, MPT, /*IsInequality*/ false);
988e5dd7070Spatrick }
989e5dd7070Spatrick
990e5dd7070Spatrick // Compute the comparison instructions for the specified comparison kind.
991e5dd7070Spatrick struct CmpInstInfo {
992e5dd7070Spatrick const char *Name;
993e5dd7070Spatrick llvm::CmpInst::Predicate FCmp;
994e5dd7070Spatrick llvm::CmpInst::Predicate SCmp;
995e5dd7070Spatrick llvm::CmpInst::Predicate UCmp;
996e5dd7070Spatrick };
997e5dd7070Spatrick CmpInstInfo InstInfo = [&]() -> CmpInstInfo {
998e5dd7070Spatrick using FI = llvm::FCmpInst;
999e5dd7070Spatrick using II = llvm::ICmpInst;
1000e5dd7070Spatrick switch (Kind) {
1001e5dd7070Spatrick case CK_Less:
1002e5dd7070Spatrick return {"cmp.lt", FI::FCMP_OLT, II::ICMP_SLT, II::ICMP_ULT};
1003e5dd7070Spatrick case CK_Greater:
1004e5dd7070Spatrick return {"cmp.gt", FI::FCMP_OGT, II::ICMP_SGT, II::ICMP_UGT};
1005e5dd7070Spatrick case CK_Equal:
1006e5dd7070Spatrick return {"cmp.eq", FI::FCMP_OEQ, II::ICMP_EQ, II::ICMP_EQ};
1007e5dd7070Spatrick }
1008e5dd7070Spatrick llvm_unreachable("Unrecognised CompareKind enum");
1009e5dd7070Spatrick }();
1010e5dd7070Spatrick
1011e5dd7070Spatrick if (ArgTy->hasFloatingRepresentation())
1012e5dd7070Spatrick return Builder.CreateFCmp(InstInfo.FCmp, LHS, RHS,
1013e5dd7070Spatrick llvm::Twine(InstInfo.Name) + NameSuffix);
1014e5dd7070Spatrick if (ArgTy->isIntegralOrEnumerationType() || ArgTy->isPointerType()) {
1015e5dd7070Spatrick auto Inst =
1016e5dd7070Spatrick ArgTy->hasSignedIntegerRepresentation() ? InstInfo.SCmp : InstInfo.UCmp;
1017e5dd7070Spatrick return Builder.CreateICmp(Inst, LHS, RHS,
1018e5dd7070Spatrick llvm::Twine(InstInfo.Name) + NameSuffix);
1019e5dd7070Spatrick }
1020e5dd7070Spatrick
1021e5dd7070Spatrick llvm_unreachable("unsupported aggregate binary expression should have "
1022e5dd7070Spatrick "already been handled");
1023e5dd7070Spatrick }
1024e5dd7070Spatrick
VisitBinCmp(const BinaryOperator * E)1025e5dd7070Spatrick void AggExprEmitter::VisitBinCmp(const BinaryOperator *E) {
1026e5dd7070Spatrick using llvm::BasicBlock;
1027e5dd7070Spatrick using llvm::PHINode;
1028e5dd7070Spatrick using llvm::Value;
1029e5dd7070Spatrick assert(CGF.getContext().hasSameType(E->getLHS()->getType(),
1030e5dd7070Spatrick E->getRHS()->getType()));
1031e5dd7070Spatrick const ComparisonCategoryInfo &CmpInfo =
1032e5dd7070Spatrick CGF.getContext().CompCategories.getInfoForType(E->getType());
1033e5dd7070Spatrick assert(CmpInfo.Record->isTriviallyCopyable() &&
1034e5dd7070Spatrick "cannot copy non-trivially copyable aggregate");
1035e5dd7070Spatrick
1036e5dd7070Spatrick QualType ArgTy = E->getLHS()->getType();
1037e5dd7070Spatrick
1038e5dd7070Spatrick if (!ArgTy->isIntegralOrEnumerationType() && !ArgTy->isRealFloatingType() &&
1039e5dd7070Spatrick !ArgTy->isNullPtrType() && !ArgTy->isPointerType() &&
1040e5dd7070Spatrick !ArgTy->isMemberPointerType() && !ArgTy->isAnyComplexType()) {
1041e5dd7070Spatrick return CGF.ErrorUnsupported(E, "aggregate three-way comparison");
1042e5dd7070Spatrick }
1043e5dd7070Spatrick bool IsComplex = ArgTy->isAnyComplexType();
1044e5dd7070Spatrick
1045e5dd7070Spatrick // Evaluate the operands to the expression and extract their values.
1046e5dd7070Spatrick auto EmitOperand = [&](Expr *E) -> std::pair<Value *, Value *> {
1047e5dd7070Spatrick RValue RV = CGF.EmitAnyExpr(E);
1048e5dd7070Spatrick if (RV.isScalar())
1049e5dd7070Spatrick return {RV.getScalarVal(), nullptr};
1050e5dd7070Spatrick if (RV.isAggregate())
1051e5dd7070Spatrick return {RV.getAggregatePointer(), nullptr};
1052e5dd7070Spatrick assert(RV.isComplex());
1053e5dd7070Spatrick return RV.getComplexVal();
1054e5dd7070Spatrick };
1055e5dd7070Spatrick auto LHSValues = EmitOperand(E->getLHS()),
1056e5dd7070Spatrick RHSValues = EmitOperand(E->getRHS());
1057e5dd7070Spatrick
1058e5dd7070Spatrick auto EmitCmp = [&](CompareKind K) {
1059e5dd7070Spatrick Value *Cmp = EmitCompare(Builder, CGF, E, LHSValues.first, RHSValues.first,
1060e5dd7070Spatrick K, IsComplex ? ".r" : "");
1061e5dd7070Spatrick if (!IsComplex)
1062e5dd7070Spatrick return Cmp;
1063e5dd7070Spatrick assert(K == CompareKind::CK_Equal);
1064e5dd7070Spatrick Value *CmpImag = EmitCompare(Builder, CGF, E, LHSValues.second,
1065e5dd7070Spatrick RHSValues.second, K, ".i");
1066e5dd7070Spatrick return Builder.CreateAnd(Cmp, CmpImag, "and.eq");
1067e5dd7070Spatrick };
1068e5dd7070Spatrick auto EmitCmpRes = [&](const ComparisonCategoryInfo::ValueInfo *VInfo) {
1069e5dd7070Spatrick return Builder.getInt(VInfo->getIntValue());
1070e5dd7070Spatrick };
1071e5dd7070Spatrick
1072e5dd7070Spatrick Value *Select;
1073e5dd7070Spatrick if (ArgTy->isNullPtrType()) {
1074e5dd7070Spatrick Select = EmitCmpRes(CmpInfo.getEqualOrEquiv());
1075e5dd7070Spatrick } else if (!CmpInfo.isPartial()) {
1076e5dd7070Spatrick Value *SelectOne =
1077e5dd7070Spatrick Builder.CreateSelect(EmitCmp(CK_Less), EmitCmpRes(CmpInfo.getLess()),
1078e5dd7070Spatrick EmitCmpRes(CmpInfo.getGreater()), "sel.lt");
1079e5dd7070Spatrick Select = Builder.CreateSelect(EmitCmp(CK_Equal),
1080e5dd7070Spatrick EmitCmpRes(CmpInfo.getEqualOrEquiv()),
1081e5dd7070Spatrick SelectOne, "sel.eq");
1082e5dd7070Spatrick } else {
1083e5dd7070Spatrick Value *SelectEq = Builder.CreateSelect(
1084e5dd7070Spatrick EmitCmp(CK_Equal), EmitCmpRes(CmpInfo.getEqualOrEquiv()),
1085e5dd7070Spatrick EmitCmpRes(CmpInfo.getUnordered()), "sel.eq");
1086e5dd7070Spatrick Value *SelectGT = Builder.CreateSelect(EmitCmp(CK_Greater),
1087e5dd7070Spatrick EmitCmpRes(CmpInfo.getGreater()),
1088e5dd7070Spatrick SelectEq, "sel.gt");
1089e5dd7070Spatrick Select = Builder.CreateSelect(
1090e5dd7070Spatrick EmitCmp(CK_Less), EmitCmpRes(CmpInfo.getLess()), SelectGT, "sel.lt");
1091e5dd7070Spatrick }
1092e5dd7070Spatrick // Create the return value in the destination slot.
1093e5dd7070Spatrick EnsureDest(E->getType());
1094e5dd7070Spatrick LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType());
1095e5dd7070Spatrick
1096e5dd7070Spatrick // Emit the address of the first (and only) field in the comparison category
1097e5dd7070Spatrick // type, and initialize it from the constant integer value selected above.
1098e5dd7070Spatrick LValue FieldLV = CGF.EmitLValueForFieldInitialization(
1099e5dd7070Spatrick DestLV, *CmpInfo.Record->field_begin());
1100e5dd7070Spatrick CGF.EmitStoreThroughLValue(RValue::get(Select), FieldLV, /*IsInit*/ true);
1101e5dd7070Spatrick
1102e5dd7070Spatrick // All done! The result is in the Dest slot.
1103e5dd7070Spatrick }
1104e5dd7070Spatrick
VisitBinaryOperator(const BinaryOperator * E)1105e5dd7070Spatrick void AggExprEmitter::VisitBinaryOperator(const BinaryOperator *E) {
1106e5dd7070Spatrick if (E->getOpcode() == BO_PtrMemD || E->getOpcode() == BO_PtrMemI)
1107e5dd7070Spatrick VisitPointerToDataMemberBinaryOperator(E);
1108e5dd7070Spatrick else
1109e5dd7070Spatrick CGF.ErrorUnsupported(E, "aggregate binary expression");
1110e5dd7070Spatrick }
1111e5dd7070Spatrick
VisitPointerToDataMemberBinaryOperator(const BinaryOperator * E)1112e5dd7070Spatrick void AggExprEmitter::VisitPointerToDataMemberBinaryOperator(
1113e5dd7070Spatrick const BinaryOperator *E) {
1114e5dd7070Spatrick LValue LV = CGF.EmitPointerToDataMemberBinaryExpr(E);
1115e5dd7070Spatrick EmitFinalDestCopy(E->getType(), LV);
1116e5dd7070Spatrick }
1117e5dd7070Spatrick
1118e5dd7070Spatrick /// Is the value of the given expression possibly a reference to or
1119e5dd7070Spatrick /// into a __block variable?
isBlockVarRef(const Expr * E)1120e5dd7070Spatrick static bool isBlockVarRef(const Expr *E) {
1121e5dd7070Spatrick // Make sure we look through parens.
1122e5dd7070Spatrick E = E->IgnoreParens();
1123e5dd7070Spatrick
1124e5dd7070Spatrick // Check for a direct reference to a __block variable.
1125e5dd7070Spatrick if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
1126e5dd7070Spatrick const VarDecl *var = dyn_cast<VarDecl>(DRE->getDecl());
1127e5dd7070Spatrick return (var && var->hasAttr<BlocksAttr>());
1128e5dd7070Spatrick }
1129e5dd7070Spatrick
1130e5dd7070Spatrick // More complicated stuff.
1131e5dd7070Spatrick
1132e5dd7070Spatrick // Binary operators.
1133e5dd7070Spatrick if (const BinaryOperator *op = dyn_cast<BinaryOperator>(E)) {
1134e5dd7070Spatrick // For an assignment or pointer-to-member operation, just care
1135e5dd7070Spatrick // about the LHS.
1136e5dd7070Spatrick if (op->isAssignmentOp() || op->isPtrMemOp())
1137e5dd7070Spatrick return isBlockVarRef(op->getLHS());
1138e5dd7070Spatrick
1139e5dd7070Spatrick // For a comma, just care about the RHS.
1140e5dd7070Spatrick if (op->getOpcode() == BO_Comma)
1141e5dd7070Spatrick return isBlockVarRef(op->getRHS());
1142e5dd7070Spatrick
1143e5dd7070Spatrick // FIXME: pointer arithmetic?
1144e5dd7070Spatrick return false;
1145e5dd7070Spatrick
1146e5dd7070Spatrick // Check both sides of a conditional operator.
1147e5dd7070Spatrick } else if (const AbstractConditionalOperator *op
1148e5dd7070Spatrick = dyn_cast<AbstractConditionalOperator>(E)) {
1149e5dd7070Spatrick return isBlockVarRef(op->getTrueExpr())
1150e5dd7070Spatrick || isBlockVarRef(op->getFalseExpr());
1151e5dd7070Spatrick
1152e5dd7070Spatrick // OVEs are required to support BinaryConditionalOperators.
1153e5dd7070Spatrick } else if (const OpaqueValueExpr *op
1154e5dd7070Spatrick = dyn_cast<OpaqueValueExpr>(E)) {
1155e5dd7070Spatrick if (const Expr *src = op->getSourceExpr())
1156e5dd7070Spatrick return isBlockVarRef(src);
1157e5dd7070Spatrick
1158e5dd7070Spatrick // Casts are necessary to get things like (*(int*)&var) = foo().
1159e5dd7070Spatrick // We don't really care about the kind of cast here, except
1160e5dd7070Spatrick // we don't want to look through l2r casts, because it's okay
1161e5dd7070Spatrick // to get the *value* in a __block variable.
1162e5dd7070Spatrick } else if (const CastExpr *cast = dyn_cast<CastExpr>(E)) {
1163e5dd7070Spatrick if (cast->getCastKind() == CK_LValueToRValue)
1164e5dd7070Spatrick return false;
1165e5dd7070Spatrick return isBlockVarRef(cast->getSubExpr());
1166e5dd7070Spatrick
1167e5dd7070Spatrick // Handle unary operators. Again, just aggressively look through
1168e5dd7070Spatrick // it, ignoring the operation.
1169e5dd7070Spatrick } else if (const UnaryOperator *uop = dyn_cast<UnaryOperator>(E)) {
1170e5dd7070Spatrick return isBlockVarRef(uop->getSubExpr());
1171e5dd7070Spatrick
1172e5dd7070Spatrick // Look into the base of a field access.
1173e5dd7070Spatrick } else if (const MemberExpr *mem = dyn_cast<MemberExpr>(E)) {
1174e5dd7070Spatrick return isBlockVarRef(mem->getBase());
1175e5dd7070Spatrick
1176e5dd7070Spatrick // Look into the base of a subscript.
1177e5dd7070Spatrick } else if (const ArraySubscriptExpr *sub = dyn_cast<ArraySubscriptExpr>(E)) {
1178e5dd7070Spatrick return isBlockVarRef(sub->getBase());
1179e5dd7070Spatrick }
1180e5dd7070Spatrick
1181e5dd7070Spatrick return false;
1182e5dd7070Spatrick }
1183e5dd7070Spatrick
VisitBinAssign(const BinaryOperator * E)1184e5dd7070Spatrick void AggExprEmitter::VisitBinAssign(const BinaryOperator *E) {
1185e5dd7070Spatrick // For an assignment to work, the value on the right has
1186e5dd7070Spatrick // to be compatible with the value on the left.
1187e5dd7070Spatrick assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(),
1188e5dd7070Spatrick E->getRHS()->getType())
1189e5dd7070Spatrick && "Invalid assignment");
1190e5dd7070Spatrick
1191e5dd7070Spatrick // If the LHS might be a __block variable, and the RHS can
1192e5dd7070Spatrick // potentially cause a block copy, we need to evaluate the RHS first
1193e5dd7070Spatrick // so that the assignment goes the right place.
1194e5dd7070Spatrick // This is pretty semantically fragile.
1195e5dd7070Spatrick if (isBlockVarRef(E->getLHS()) &&
1196e5dd7070Spatrick E->getRHS()->HasSideEffects(CGF.getContext())) {
1197e5dd7070Spatrick // Ensure that we have a destination, and evaluate the RHS into that.
1198e5dd7070Spatrick EnsureDest(E->getRHS()->getType());
1199e5dd7070Spatrick Visit(E->getRHS());
1200e5dd7070Spatrick
1201e5dd7070Spatrick // Now emit the LHS and copy into it.
1202e5dd7070Spatrick LValue LHS = CGF.EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store);
1203e5dd7070Spatrick
1204e5dd7070Spatrick // That copy is an atomic copy if the LHS is atomic.
1205e5dd7070Spatrick if (LHS.getType()->isAtomicType() ||
1206e5dd7070Spatrick CGF.LValueIsSuitableForInlineAtomic(LHS)) {
1207e5dd7070Spatrick CGF.EmitAtomicStore(Dest.asRValue(), LHS, /*isInit*/ false);
1208e5dd7070Spatrick return;
1209e5dd7070Spatrick }
1210e5dd7070Spatrick
1211e5dd7070Spatrick EmitCopy(E->getLHS()->getType(),
1212e5dd7070Spatrick AggValueSlot::forLValue(LHS, CGF, AggValueSlot::IsDestructed,
1213e5dd7070Spatrick needsGC(E->getLHS()->getType()),
1214e5dd7070Spatrick AggValueSlot::IsAliased,
1215e5dd7070Spatrick AggValueSlot::MayOverlap),
1216e5dd7070Spatrick Dest);
1217e5dd7070Spatrick return;
1218e5dd7070Spatrick }
1219e5dd7070Spatrick
1220e5dd7070Spatrick LValue LHS = CGF.EmitLValue(E->getLHS());
1221e5dd7070Spatrick
1222e5dd7070Spatrick // If we have an atomic type, evaluate into the destination and then
1223e5dd7070Spatrick // do an atomic copy.
1224e5dd7070Spatrick if (LHS.getType()->isAtomicType() ||
1225e5dd7070Spatrick CGF.LValueIsSuitableForInlineAtomic(LHS)) {
1226e5dd7070Spatrick EnsureDest(E->getRHS()->getType());
1227e5dd7070Spatrick Visit(E->getRHS());
1228e5dd7070Spatrick CGF.EmitAtomicStore(Dest.asRValue(), LHS, /*isInit*/ false);
1229e5dd7070Spatrick return;
1230e5dd7070Spatrick }
1231e5dd7070Spatrick
1232e5dd7070Spatrick // Codegen the RHS so that it stores directly into the LHS.
1233e5dd7070Spatrick AggValueSlot LHSSlot = AggValueSlot::forLValue(
1234e5dd7070Spatrick LHS, CGF, AggValueSlot::IsDestructed, needsGC(E->getLHS()->getType()),
1235e5dd7070Spatrick AggValueSlot::IsAliased, AggValueSlot::MayOverlap);
1236e5dd7070Spatrick // A non-volatile aggregate destination might have volatile member.
1237e5dd7070Spatrick if (!LHSSlot.isVolatile() &&
1238e5dd7070Spatrick CGF.hasVolatileMember(E->getLHS()->getType()))
1239e5dd7070Spatrick LHSSlot.setVolatile(true);
1240e5dd7070Spatrick
1241e5dd7070Spatrick CGF.EmitAggExpr(E->getRHS(), LHSSlot);
1242e5dd7070Spatrick
1243e5dd7070Spatrick // Copy into the destination if the assignment isn't ignored.
1244e5dd7070Spatrick EmitFinalDestCopy(E->getType(), LHS);
1245a9ac8606Spatrick
1246a9ac8606Spatrick if (!Dest.isIgnored() && !Dest.isExternallyDestructed() &&
1247a9ac8606Spatrick E->getType().isDestructedType() == QualType::DK_nontrivial_c_struct)
1248a9ac8606Spatrick CGF.pushDestroy(QualType::DK_nontrivial_c_struct, Dest.getAddress(),
1249a9ac8606Spatrick E->getType());
1250e5dd7070Spatrick }
1251e5dd7070Spatrick
1252e5dd7070Spatrick void AggExprEmitter::
VisitAbstractConditionalOperator(const AbstractConditionalOperator * E)1253e5dd7070Spatrick VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
1254e5dd7070Spatrick llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
1255e5dd7070Spatrick llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
1256e5dd7070Spatrick llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
1257e5dd7070Spatrick
1258e5dd7070Spatrick // Bind the common expression if necessary.
1259e5dd7070Spatrick CodeGenFunction::OpaqueValueMapping binding(CGF, E);
1260e5dd7070Spatrick
1261e5dd7070Spatrick CodeGenFunction::ConditionalEvaluation eval(CGF);
1262e5dd7070Spatrick CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock,
1263e5dd7070Spatrick CGF.getProfileCount(E));
1264e5dd7070Spatrick
1265e5dd7070Spatrick // Save whether the destination's lifetime is externally managed.
1266e5dd7070Spatrick bool isExternallyDestructed = Dest.isExternallyDestructed();
1267a9ac8606Spatrick bool destructNonTrivialCStruct =
1268a9ac8606Spatrick !isExternallyDestructed &&
1269a9ac8606Spatrick E->getType().isDestructedType() == QualType::DK_nontrivial_c_struct;
1270a9ac8606Spatrick isExternallyDestructed |= destructNonTrivialCStruct;
1271a9ac8606Spatrick Dest.setExternallyDestructed(isExternallyDestructed);
1272e5dd7070Spatrick
1273e5dd7070Spatrick eval.begin(CGF);
1274e5dd7070Spatrick CGF.EmitBlock(LHSBlock);
1275e5dd7070Spatrick CGF.incrementProfileCounter(E);
1276e5dd7070Spatrick Visit(E->getTrueExpr());
1277e5dd7070Spatrick eval.end(CGF);
1278e5dd7070Spatrick
1279e5dd7070Spatrick assert(CGF.HaveInsertPoint() && "expression evaluation ended with no IP!");
1280e5dd7070Spatrick CGF.Builder.CreateBr(ContBlock);
1281e5dd7070Spatrick
1282e5dd7070Spatrick // If the result of an agg expression is unused, then the emission
1283e5dd7070Spatrick // of the LHS might need to create a destination slot. That's fine
1284e5dd7070Spatrick // with us, and we can safely emit the RHS into the same slot, but
1285e5dd7070Spatrick // we shouldn't claim that it's already being destructed.
1286e5dd7070Spatrick Dest.setExternallyDestructed(isExternallyDestructed);
1287e5dd7070Spatrick
1288e5dd7070Spatrick eval.begin(CGF);
1289e5dd7070Spatrick CGF.EmitBlock(RHSBlock);
1290e5dd7070Spatrick Visit(E->getFalseExpr());
1291e5dd7070Spatrick eval.end(CGF);
1292e5dd7070Spatrick
1293a9ac8606Spatrick if (destructNonTrivialCStruct)
1294a9ac8606Spatrick CGF.pushDestroy(QualType::DK_nontrivial_c_struct, Dest.getAddress(),
1295a9ac8606Spatrick E->getType());
1296a9ac8606Spatrick
1297e5dd7070Spatrick CGF.EmitBlock(ContBlock);
1298e5dd7070Spatrick }
1299e5dd7070Spatrick
VisitChooseExpr(const ChooseExpr * CE)1300e5dd7070Spatrick void AggExprEmitter::VisitChooseExpr(const ChooseExpr *CE) {
1301e5dd7070Spatrick Visit(CE->getChosenSubExpr());
1302e5dd7070Spatrick }
1303e5dd7070Spatrick
VisitVAArgExpr(VAArgExpr * VE)1304e5dd7070Spatrick void AggExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
1305e5dd7070Spatrick Address ArgValue = Address::invalid();
1306e5dd7070Spatrick Address ArgPtr = CGF.EmitVAArg(VE, ArgValue);
1307e5dd7070Spatrick
1308e5dd7070Spatrick // If EmitVAArg fails, emit an error.
1309e5dd7070Spatrick if (!ArgPtr.isValid()) {
1310e5dd7070Spatrick CGF.ErrorUnsupported(VE, "aggregate va_arg expression");
1311e5dd7070Spatrick return;
1312e5dd7070Spatrick }
1313e5dd7070Spatrick
1314e5dd7070Spatrick EmitFinalDestCopy(VE->getType(), CGF.MakeAddrLValue(ArgPtr, VE->getType()));
1315e5dd7070Spatrick }
1316e5dd7070Spatrick
VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr * E)1317e5dd7070Spatrick void AggExprEmitter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1318e5dd7070Spatrick // Ensure that we have a slot, but if we already do, remember
1319e5dd7070Spatrick // whether it was externally destructed.
1320e5dd7070Spatrick bool wasExternallyDestructed = Dest.isExternallyDestructed();
1321e5dd7070Spatrick EnsureDest(E->getType());
1322e5dd7070Spatrick
1323e5dd7070Spatrick // We're going to push a destructor if there isn't already one.
1324e5dd7070Spatrick Dest.setExternallyDestructed();
1325e5dd7070Spatrick
1326e5dd7070Spatrick Visit(E->getSubExpr());
1327e5dd7070Spatrick
1328e5dd7070Spatrick // Push that destructor we promised.
1329e5dd7070Spatrick if (!wasExternallyDestructed)
1330e5dd7070Spatrick CGF.EmitCXXTemporary(E->getTemporary(), E->getType(), Dest.getAddress());
1331e5dd7070Spatrick }
1332e5dd7070Spatrick
1333e5dd7070Spatrick void
VisitCXXConstructExpr(const CXXConstructExpr * E)1334e5dd7070Spatrick AggExprEmitter::VisitCXXConstructExpr(const CXXConstructExpr *E) {
1335e5dd7070Spatrick AggValueSlot Slot = EnsureSlot(E->getType());
1336e5dd7070Spatrick CGF.EmitCXXConstructExpr(E, Slot);
1337e5dd7070Spatrick }
1338e5dd7070Spatrick
VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr * E)1339e5dd7070Spatrick void AggExprEmitter::VisitCXXInheritedCtorInitExpr(
1340e5dd7070Spatrick const CXXInheritedCtorInitExpr *E) {
1341e5dd7070Spatrick AggValueSlot Slot = EnsureSlot(E->getType());
1342e5dd7070Spatrick CGF.EmitInheritedCXXConstructorCall(
1343e5dd7070Spatrick E->getConstructor(), E->constructsVBase(), Slot.getAddress(),
1344e5dd7070Spatrick E->inheritedFromVBase(), E);
1345e5dd7070Spatrick }
1346e5dd7070Spatrick
1347e5dd7070Spatrick void
VisitLambdaExpr(LambdaExpr * E)1348e5dd7070Spatrick AggExprEmitter::VisitLambdaExpr(LambdaExpr *E) {
1349e5dd7070Spatrick AggValueSlot Slot = EnsureSlot(E->getType());
1350e5dd7070Spatrick LValue SlotLV = CGF.MakeAddrLValue(Slot.getAddress(), E->getType());
1351e5dd7070Spatrick
1352e5dd7070Spatrick // We'll need to enter cleanup scopes in case any of the element
1353e5dd7070Spatrick // initializers throws an exception.
1354e5dd7070Spatrick SmallVector<EHScopeStack::stable_iterator, 16> Cleanups;
1355e5dd7070Spatrick llvm::Instruction *CleanupDominator = nullptr;
1356e5dd7070Spatrick
1357e5dd7070Spatrick CXXRecordDecl::field_iterator CurField = E->getLambdaClass()->field_begin();
1358e5dd7070Spatrick for (LambdaExpr::const_capture_init_iterator i = E->capture_init_begin(),
1359e5dd7070Spatrick e = E->capture_init_end();
1360e5dd7070Spatrick i != e; ++i, ++CurField) {
1361e5dd7070Spatrick // Emit initialization
1362e5dd7070Spatrick LValue LV = CGF.EmitLValueForFieldInitialization(SlotLV, *CurField);
1363e5dd7070Spatrick if (CurField->hasCapturedVLAType()) {
1364e5dd7070Spatrick CGF.EmitLambdaVLACapture(CurField->getCapturedVLAType(), LV);
1365e5dd7070Spatrick continue;
1366e5dd7070Spatrick }
1367e5dd7070Spatrick
1368e5dd7070Spatrick EmitInitializationToLValue(*i, LV);
1369e5dd7070Spatrick
1370e5dd7070Spatrick // Push a destructor if necessary.
1371e5dd7070Spatrick if (QualType::DestructionKind DtorKind =
1372e5dd7070Spatrick CurField->getType().isDestructedType()) {
1373e5dd7070Spatrick assert(LV.isSimple());
1374e5dd7070Spatrick if (CGF.needsEHCleanup(DtorKind)) {
1375e5dd7070Spatrick if (!CleanupDominator)
1376e5dd7070Spatrick CleanupDominator = CGF.Builder.CreateAlignedLoad(
1377e5dd7070Spatrick CGF.Int8Ty,
1378e5dd7070Spatrick llvm::Constant::getNullValue(CGF.Int8PtrTy),
1379e5dd7070Spatrick CharUnits::One()); // placeholder
1380e5dd7070Spatrick
1381e5dd7070Spatrick CGF.pushDestroy(EHCleanup, LV.getAddress(CGF), CurField->getType(),
1382e5dd7070Spatrick CGF.getDestroyer(DtorKind), false);
1383e5dd7070Spatrick Cleanups.push_back(CGF.EHStack.stable_begin());
1384e5dd7070Spatrick }
1385e5dd7070Spatrick }
1386e5dd7070Spatrick }
1387e5dd7070Spatrick
1388e5dd7070Spatrick // Deactivate all the partial cleanups in reverse order, which
1389e5dd7070Spatrick // generally means popping them.
1390e5dd7070Spatrick for (unsigned i = Cleanups.size(); i != 0; --i)
1391e5dd7070Spatrick CGF.DeactivateCleanupBlock(Cleanups[i-1], CleanupDominator);
1392e5dd7070Spatrick
1393e5dd7070Spatrick // Destroy the placeholder if we made one.
1394e5dd7070Spatrick if (CleanupDominator)
1395e5dd7070Spatrick CleanupDominator->eraseFromParent();
1396e5dd7070Spatrick }
1397e5dd7070Spatrick
VisitExprWithCleanups(ExprWithCleanups * E)1398e5dd7070Spatrick void AggExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) {
1399e5dd7070Spatrick CodeGenFunction::RunCleanupsScope cleanups(CGF);
1400e5dd7070Spatrick Visit(E->getSubExpr());
1401e5dd7070Spatrick }
1402e5dd7070Spatrick
VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr * E)1403e5dd7070Spatrick void AggExprEmitter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1404e5dd7070Spatrick QualType T = E->getType();
1405e5dd7070Spatrick AggValueSlot Slot = EnsureSlot(T);
1406e5dd7070Spatrick EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddress(), T));
1407e5dd7070Spatrick }
1408e5dd7070Spatrick
VisitImplicitValueInitExpr(ImplicitValueInitExpr * E)1409e5dd7070Spatrick void AggExprEmitter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
1410e5dd7070Spatrick QualType T = E->getType();
1411e5dd7070Spatrick AggValueSlot Slot = EnsureSlot(T);
1412e5dd7070Spatrick EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddress(), T));
1413e5dd7070Spatrick }
1414e5dd7070Spatrick
1415a9ac8606Spatrick /// Determine whether the given cast kind is known to always convert values
1416a9ac8606Spatrick /// with all zero bits in their value representation to values with all zero
1417a9ac8606Spatrick /// bits in their value representation.
castPreservesZero(const CastExpr * CE)1418a9ac8606Spatrick static bool castPreservesZero(const CastExpr *CE) {
1419a9ac8606Spatrick switch (CE->getCastKind()) {
1420a9ac8606Spatrick // No-ops.
1421a9ac8606Spatrick case CK_NoOp:
1422a9ac8606Spatrick case CK_UserDefinedConversion:
1423a9ac8606Spatrick case CK_ConstructorConversion:
1424a9ac8606Spatrick case CK_BitCast:
1425a9ac8606Spatrick case CK_ToUnion:
1426a9ac8606Spatrick case CK_ToVoid:
1427a9ac8606Spatrick // Conversions between (possibly-complex) integral, (possibly-complex)
1428a9ac8606Spatrick // floating-point, and bool.
1429a9ac8606Spatrick case CK_BooleanToSignedIntegral:
1430a9ac8606Spatrick case CK_FloatingCast:
1431a9ac8606Spatrick case CK_FloatingComplexCast:
1432a9ac8606Spatrick case CK_FloatingComplexToBoolean:
1433a9ac8606Spatrick case CK_FloatingComplexToIntegralComplex:
1434a9ac8606Spatrick case CK_FloatingComplexToReal:
1435a9ac8606Spatrick case CK_FloatingRealToComplex:
1436a9ac8606Spatrick case CK_FloatingToBoolean:
1437a9ac8606Spatrick case CK_FloatingToIntegral:
1438a9ac8606Spatrick case CK_IntegralCast:
1439a9ac8606Spatrick case CK_IntegralComplexCast:
1440a9ac8606Spatrick case CK_IntegralComplexToBoolean:
1441a9ac8606Spatrick case CK_IntegralComplexToFloatingComplex:
1442a9ac8606Spatrick case CK_IntegralComplexToReal:
1443a9ac8606Spatrick case CK_IntegralRealToComplex:
1444a9ac8606Spatrick case CK_IntegralToBoolean:
1445a9ac8606Spatrick case CK_IntegralToFloating:
1446a9ac8606Spatrick // Reinterpreting integers as pointers and vice versa.
1447a9ac8606Spatrick case CK_IntegralToPointer:
1448a9ac8606Spatrick case CK_PointerToIntegral:
1449a9ac8606Spatrick // Language extensions.
1450a9ac8606Spatrick case CK_VectorSplat:
1451a9ac8606Spatrick case CK_MatrixCast:
1452a9ac8606Spatrick case CK_NonAtomicToAtomic:
1453a9ac8606Spatrick case CK_AtomicToNonAtomic:
1454a9ac8606Spatrick return true;
1455a9ac8606Spatrick
1456a9ac8606Spatrick case CK_BaseToDerivedMemberPointer:
1457a9ac8606Spatrick case CK_DerivedToBaseMemberPointer:
1458a9ac8606Spatrick case CK_MemberPointerToBoolean:
1459a9ac8606Spatrick case CK_NullToMemberPointer:
1460a9ac8606Spatrick case CK_ReinterpretMemberPointer:
1461a9ac8606Spatrick // FIXME: ABI-dependent.
1462a9ac8606Spatrick return false;
1463a9ac8606Spatrick
1464a9ac8606Spatrick case CK_AnyPointerToBlockPointerCast:
1465a9ac8606Spatrick case CK_BlockPointerToObjCPointerCast:
1466a9ac8606Spatrick case CK_CPointerToObjCPointerCast:
1467a9ac8606Spatrick case CK_ObjCObjectLValueCast:
1468a9ac8606Spatrick case CK_IntToOCLSampler:
1469a9ac8606Spatrick case CK_ZeroToOCLOpaqueType:
1470a9ac8606Spatrick // FIXME: Check these.
1471a9ac8606Spatrick return false;
1472a9ac8606Spatrick
1473a9ac8606Spatrick case CK_FixedPointCast:
1474a9ac8606Spatrick case CK_FixedPointToBoolean:
1475a9ac8606Spatrick case CK_FixedPointToFloating:
1476a9ac8606Spatrick case CK_FixedPointToIntegral:
1477a9ac8606Spatrick case CK_FloatingToFixedPoint:
1478a9ac8606Spatrick case CK_IntegralToFixedPoint:
1479a9ac8606Spatrick // FIXME: Do all fixed-point types represent zero as all 0 bits?
1480a9ac8606Spatrick return false;
1481a9ac8606Spatrick
1482a9ac8606Spatrick case CK_AddressSpaceConversion:
1483a9ac8606Spatrick case CK_BaseToDerived:
1484a9ac8606Spatrick case CK_DerivedToBase:
1485a9ac8606Spatrick case CK_Dynamic:
1486a9ac8606Spatrick case CK_NullToPointer:
1487a9ac8606Spatrick case CK_PointerToBoolean:
1488a9ac8606Spatrick // FIXME: Preserves zeroes only if zero pointers and null pointers have the
1489a9ac8606Spatrick // same representation in all involved address spaces.
1490a9ac8606Spatrick return false;
1491a9ac8606Spatrick
1492a9ac8606Spatrick case CK_ARCConsumeObject:
1493a9ac8606Spatrick case CK_ARCExtendBlockObject:
1494a9ac8606Spatrick case CK_ARCProduceObject:
1495a9ac8606Spatrick case CK_ARCReclaimReturnedObject:
1496a9ac8606Spatrick case CK_CopyAndAutoreleaseBlockObject:
1497a9ac8606Spatrick case CK_ArrayToPointerDecay:
1498a9ac8606Spatrick case CK_FunctionToPointerDecay:
1499a9ac8606Spatrick case CK_BuiltinFnToFnPtr:
1500a9ac8606Spatrick case CK_Dependent:
1501a9ac8606Spatrick case CK_LValueBitCast:
1502a9ac8606Spatrick case CK_LValueToRValue:
1503a9ac8606Spatrick case CK_LValueToRValueBitCast:
1504a9ac8606Spatrick case CK_UncheckedDerivedToBase:
1505a9ac8606Spatrick return false;
1506a9ac8606Spatrick }
1507a9ac8606Spatrick llvm_unreachable("Unhandled clang::CastKind enum");
1508a9ac8606Spatrick }
1509a9ac8606Spatrick
1510e5dd7070Spatrick /// isSimpleZero - If emitting this value will obviously just cause a store of
1511e5dd7070Spatrick /// zero to memory, return true. This can return false if uncertain, so it just
1512e5dd7070Spatrick /// handles simple cases.
isSimpleZero(const Expr * E,CodeGenFunction & CGF)1513e5dd7070Spatrick static bool isSimpleZero(const Expr *E, CodeGenFunction &CGF) {
1514e5dd7070Spatrick E = E->IgnoreParens();
1515a9ac8606Spatrick while (auto *CE = dyn_cast<CastExpr>(E)) {
1516a9ac8606Spatrick if (!castPreservesZero(CE))
1517a9ac8606Spatrick break;
1518a9ac8606Spatrick E = CE->getSubExpr()->IgnoreParens();
1519a9ac8606Spatrick }
1520e5dd7070Spatrick
1521e5dd7070Spatrick // 0
1522e5dd7070Spatrick if (const IntegerLiteral *IL = dyn_cast<IntegerLiteral>(E))
1523e5dd7070Spatrick return IL->getValue() == 0;
1524e5dd7070Spatrick // +0.0
1525e5dd7070Spatrick if (const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(E))
1526e5dd7070Spatrick return FL->getValue().isPosZero();
1527e5dd7070Spatrick // int()
1528e5dd7070Spatrick if ((isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) &&
1529e5dd7070Spatrick CGF.getTypes().isZeroInitializable(E->getType()))
1530e5dd7070Spatrick return true;
1531e5dd7070Spatrick // (int*)0 - Null pointer expressions.
1532e5dd7070Spatrick if (const CastExpr *ICE = dyn_cast<CastExpr>(E))
1533e5dd7070Spatrick return ICE->getCastKind() == CK_NullToPointer &&
1534e5dd7070Spatrick CGF.getTypes().isPointerZeroInitializable(E->getType()) &&
1535e5dd7070Spatrick !E->HasSideEffects(CGF.getContext());
1536e5dd7070Spatrick // '\0'
1537e5dd7070Spatrick if (const CharacterLiteral *CL = dyn_cast<CharacterLiteral>(E))
1538e5dd7070Spatrick return CL->getValue() == 0;
1539e5dd7070Spatrick
1540e5dd7070Spatrick // Otherwise, hard case: conservatively return false.
1541e5dd7070Spatrick return false;
1542e5dd7070Spatrick }
1543e5dd7070Spatrick
1544e5dd7070Spatrick
1545e5dd7070Spatrick void
EmitInitializationToLValue(Expr * E,LValue LV)1546e5dd7070Spatrick AggExprEmitter::EmitInitializationToLValue(Expr *E, LValue LV) {
1547e5dd7070Spatrick QualType type = LV.getType();
1548e5dd7070Spatrick // FIXME: Ignore result?
1549e5dd7070Spatrick // FIXME: Are initializers affected by volatile?
1550e5dd7070Spatrick if (Dest.isZeroed() && isSimpleZero(E, CGF)) {
1551e5dd7070Spatrick // Storing "i32 0" to a zero'd memory location is a noop.
1552e5dd7070Spatrick return;
1553e5dd7070Spatrick } else if (isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) {
1554e5dd7070Spatrick return EmitNullInitializationToLValue(LV);
1555e5dd7070Spatrick } else if (isa<NoInitExpr>(E)) {
1556e5dd7070Spatrick // Do nothing.
1557e5dd7070Spatrick return;
1558e5dd7070Spatrick } else if (type->isReferenceType()) {
1559e5dd7070Spatrick RValue RV = CGF.EmitReferenceBindingToExpr(E);
1560e5dd7070Spatrick return CGF.EmitStoreThroughLValue(RV, LV);
1561e5dd7070Spatrick }
1562e5dd7070Spatrick
1563e5dd7070Spatrick switch (CGF.getEvaluationKind(type)) {
1564e5dd7070Spatrick case TEK_Complex:
1565e5dd7070Spatrick CGF.EmitComplexExprIntoLValue(E, LV, /*isInit*/ true);
1566e5dd7070Spatrick return;
1567e5dd7070Spatrick case TEK_Aggregate:
1568e5dd7070Spatrick CGF.EmitAggExpr(
1569e5dd7070Spatrick E, AggValueSlot::forLValue(LV, CGF, AggValueSlot::IsDestructed,
1570e5dd7070Spatrick AggValueSlot::DoesNotNeedGCBarriers,
1571e5dd7070Spatrick AggValueSlot::IsNotAliased,
1572e5dd7070Spatrick AggValueSlot::MayOverlap, Dest.isZeroed()));
1573e5dd7070Spatrick return;
1574e5dd7070Spatrick case TEK_Scalar:
1575e5dd7070Spatrick if (LV.isSimple()) {
1576e5dd7070Spatrick CGF.EmitScalarInit(E, /*D=*/nullptr, LV, /*Captured=*/false);
1577e5dd7070Spatrick } else {
1578e5dd7070Spatrick CGF.EmitStoreThroughLValue(RValue::get(CGF.EmitScalarExpr(E)), LV);
1579e5dd7070Spatrick }
1580e5dd7070Spatrick return;
1581e5dd7070Spatrick }
1582e5dd7070Spatrick llvm_unreachable("bad evaluation kind");
1583e5dd7070Spatrick }
1584e5dd7070Spatrick
EmitNullInitializationToLValue(LValue lv)1585e5dd7070Spatrick void AggExprEmitter::EmitNullInitializationToLValue(LValue lv) {
1586e5dd7070Spatrick QualType type = lv.getType();
1587e5dd7070Spatrick
1588e5dd7070Spatrick // If the destination slot is already zeroed out before the aggregate is
1589e5dd7070Spatrick // copied into it, we don't have to emit any zeros here.
1590e5dd7070Spatrick if (Dest.isZeroed() && CGF.getTypes().isZeroInitializable(type))
1591e5dd7070Spatrick return;
1592e5dd7070Spatrick
1593e5dd7070Spatrick if (CGF.hasScalarEvaluationKind(type)) {
1594e5dd7070Spatrick // For non-aggregates, we can store the appropriate null constant.
1595e5dd7070Spatrick llvm::Value *null = CGF.CGM.EmitNullConstant(type);
1596e5dd7070Spatrick // Note that the following is not equivalent to
1597e5dd7070Spatrick // EmitStoreThroughBitfieldLValue for ARC types.
1598e5dd7070Spatrick if (lv.isBitField()) {
1599e5dd7070Spatrick CGF.EmitStoreThroughBitfieldLValue(RValue::get(null), lv);
1600e5dd7070Spatrick } else {
1601e5dd7070Spatrick assert(lv.isSimple());
1602e5dd7070Spatrick CGF.EmitStoreOfScalar(null, lv, /* isInitialization */ true);
1603e5dd7070Spatrick }
1604e5dd7070Spatrick } else {
1605e5dd7070Spatrick // There's a potential optimization opportunity in combining
1606e5dd7070Spatrick // memsets; that would be easy for arrays, but relatively
1607e5dd7070Spatrick // difficult for structures with the current code.
1608e5dd7070Spatrick CGF.EmitNullInitialization(lv.getAddress(CGF), lv.getType());
1609e5dd7070Spatrick }
1610e5dd7070Spatrick }
1611e5dd7070Spatrick
VisitCXXParenListInitExpr(CXXParenListInitExpr * E)1612*12c85518Srobert void AggExprEmitter::VisitCXXParenListInitExpr(CXXParenListInitExpr *E) {
1613*12c85518Srobert VisitCXXParenListOrInitListExpr(E, E->getInitExprs(),
1614*12c85518Srobert E->getInitializedFieldInUnion(),
1615*12c85518Srobert E->getArrayFiller());
1616e5dd7070Spatrick }
1617*12c85518Srobert
VisitInitListExpr(InitListExpr * E)1618*12c85518Srobert void AggExprEmitter::VisitInitListExpr(InitListExpr *E) {
1619e5dd7070Spatrick if (E->hadArrayRangeDesignator())
1620e5dd7070Spatrick CGF.ErrorUnsupported(E, "GNU array range designator extension");
1621e5dd7070Spatrick
1622e5dd7070Spatrick if (E->isTransparent())
1623e5dd7070Spatrick return Visit(E->getInit(0));
1624e5dd7070Spatrick
1625*12c85518Srobert VisitCXXParenListOrInitListExpr(
1626*12c85518Srobert E, E->inits(), E->getInitializedFieldInUnion(), E->getArrayFiller());
1627*12c85518Srobert }
1628e5dd7070Spatrick
VisitCXXParenListOrInitListExpr(Expr * ExprToVisit,ArrayRef<Expr * > InitExprs,FieldDecl * InitializedFieldInUnion,Expr * ArrayFiller)1629*12c85518Srobert void AggExprEmitter::VisitCXXParenListOrInitListExpr(
1630*12c85518Srobert Expr *ExprToVisit, ArrayRef<Expr *> InitExprs,
1631*12c85518Srobert FieldDecl *InitializedFieldInUnion, Expr *ArrayFiller) {
1632*12c85518Srobert #if 0
1633*12c85518Srobert // FIXME: Assess perf here? Figure out what cases are worth optimizing here
1634*12c85518Srobert // (Length of globals? Chunks of zeroed-out space?).
1635*12c85518Srobert //
1636*12c85518Srobert // If we can, prefer a copy from a global; this is a lot less code for long
1637*12c85518Srobert // globals, and it's easier for the current optimizers to analyze.
1638*12c85518Srobert if (llvm::Constant *C =
1639*12c85518Srobert CGF.CGM.EmitConstantExpr(ExprToVisit, ExprToVisit->getType(), &CGF)) {
1640*12c85518Srobert llvm::GlobalVariable* GV =
1641*12c85518Srobert new llvm::GlobalVariable(CGF.CGM.getModule(), C->getType(), true,
1642*12c85518Srobert llvm::GlobalValue::InternalLinkage, C, "");
1643*12c85518Srobert EmitFinalDestCopy(ExprToVisit->getType(),
1644*12c85518Srobert CGF.MakeAddrLValue(GV, ExprToVisit->getType()));
1645*12c85518Srobert return;
1646*12c85518Srobert }
1647*12c85518Srobert #endif
1648*12c85518Srobert
1649*12c85518Srobert AggValueSlot Dest = EnsureSlot(ExprToVisit->getType());
1650*12c85518Srobert
1651*12c85518Srobert LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), ExprToVisit->getType());
1652e5dd7070Spatrick
1653e5dd7070Spatrick // Handle initialization of an array.
1654*12c85518Srobert if (ExprToVisit->getType()->isArrayType()) {
1655e5dd7070Spatrick auto AType = cast<llvm::ArrayType>(Dest.getAddress().getElementType());
1656*12c85518Srobert EmitArrayInit(Dest.getAddress(), AType, ExprToVisit->getType(), ExprToVisit,
1657*12c85518Srobert InitExprs, ArrayFiller);
1658e5dd7070Spatrick return;
1659e5dd7070Spatrick }
1660e5dd7070Spatrick
1661*12c85518Srobert assert(ExprToVisit->getType()->isRecordType() &&
1662*12c85518Srobert "Only support structs/unions here!");
1663e5dd7070Spatrick
1664e5dd7070Spatrick // Do struct initialization; this code just sets each individual member
1665e5dd7070Spatrick // to the approprate value. This makes bitfield support automatic;
1666e5dd7070Spatrick // the disadvantage is that the generated code is more difficult for
1667e5dd7070Spatrick // the optimizer, especially with bitfields.
1668*12c85518Srobert unsigned NumInitElements = InitExprs.size();
1669*12c85518Srobert RecordDecl *record = ExprToVisit->getType()->castAs<RecordType>()->getDecl();
1670e5dd7070Spatrick
1671e5dd7070Spatrick // We'll need to enter cleanup scopes in case any of the element
1672e5dd7070Spatrick // initializers throws an exception.
1673e5dd7070Spatrick SmallVector<EHScopeStack::stable_iterator, 16> cleanups;
1674e5dd7070Spatrick llvm::Instruction *cleanupDominator = nullptr;
1675e5dd7070Spatrick auto addCleanup = [&](const EHScopeStack::stable_iterator &cleanup) {
1676e5dd7070Spatrick cleanups.push_back(cleanup);
1677e5dd7070Spatrick if (!cleanupDominator) // create placeholder once needed
1678e5dd7070Spatrick cleanupDominator = CGF.Builder.CreateAlignedLoad(
1679e5dd7070Spatrick CGF.Int8Ty, llvm::Constant::getNullValue(CGF.Int8PtrTy),
1680e5dd7070Spatrick CharUnits::One());
1681e5dd7070Spatrick };
1682e5dd7070Spatrick
1683e5dd7070Spatrick unsigned curInitIndex = 0;
1684e5dd7070Spatrick
1685e5dd7070Spatrick // Emit initialization of base classes.
1686e5dd7070Spatrick if (auto *CXXRD = dyn_cast<CXXRecordDecl>(record)) {
1687*12c85518Srobert assert(NumInitElements >= CXXRD->getNumBases() &&
1688e5dd7070Spatrick "missing initializer for base class");
1689e5dd7070Spatrick for (auto &Base : CXXRD->bases()) {
1690e5dd7070Spatrick assert(!Base.isVirtual() && "should not see vbases here");
1691e5dd7070Spatrick auto *BaseRD = Base.getType()->getAsCXXRecordDecl();
1692e5dd7070Spatrick Address V = CGF.GetAddressOfDirectBaseInCompleteClass(
1693e5dd7070Spatrick Dest.getAddress(), CXXRD, BaseRD,
1694e5dd7070Spatrick /*isBaseVirtual*/ false);
1695e5dd7070Spatrick AggValueSlot AggSlot = AggValueSlot::forAddr(
1696e5dd7070Spatrick V, Qualifiers(),
1697e5dd7070Spatrick AggValueSlot::IsDestructed,
1698e5dd7070Spatrick AggValueSlot::DoesNotNeedGCBarriers,
1699e5dd7070Spatrick AggValueSlot::IsNotAliased,
1700e5dd7070Spatrick CGF.getOverlapForBaseInit(CXXRD, BaseRD, Base.isVirtual()));
1701*12c85518Srobert CGF.EmitAggExpr(InitExprs[curInitIndex++], AggSlot);
1702e5dd7070Spatrick
1703e5dd7070Spatrick if (QualType::DestructionKind dtorKind =
1704e5dd7070Spatrick Base.getType().isDestructedType()) {
1705e5dd7070Spatrick CGF.pushDestroy(dtorKind, V, Base.getType());
1706e5dd7070Spatrick addCleanup(CGF.EHStack.stable_begin());
1707e5dd7070Spatrick }
1708e5dd7070Spatrick }
1709e5dd7070Spatrick }
1710e5dd7070Spatrick
1711e5dd7070Spatrick // Prepare a 'this' for CXXDefaultInitExprs.
1712e5dd7070Spatrick CodeGenFunction::FieldConstructionScope FCS(CGF, Dest.getAddress());
1713e5dd7070Spatrick
1714e5dd7070Spatrick if (record->isUnion()) {
1715e5dd7070Spatrick // Only initialize one field of a union. The field itself is
1716e5dd7070Spatrick // specified by the initializer list.
1717*12c85518Srobert if (!InitializedFieldInUnion) {
1718e5dd7070Spatrick // Empty union; we have nothing to do.
1719e5dd7070Spatrick
1720e5dd7070Spatrick #ifndef NDEBUG
1721e5dd7070Spatrick // Make sure that it's really an empty and not a failure of
1722e5dd7070Spatrick // semantic analysis.
1723e5dd7070Spatrick for (const auto *Field : record->fields())
1724*12c85518Srobert assert((Field->isUnnamedBitfield() || Field->isAnonymousStructOrUnion()) && "Only unnamed bitfields or ananymous class allowed");
1725e5dd7070Spatrick #endif
1726e5dd7070Spatrick return;
1727e5dd7070Spatrick }
1728e5dd7070Spatrick
1729e5dd7070Spatrick // FIXME: volatility
1730*12c85518Srobert FieldDecl *Field = InitializedFieldInUnion;
1731e5dd7070Spatrick
1732e5dd7070Spatrick LValue FieldLoc = CGF.EmitLValueForFieldInitialization(DestLV, Field);
1733e5dd7070Spatrick if (NumInitElements) {
1734e5dd7070Spatrick // Store the initializer into the field
1735*12c85518Srobert EmitInitializationToLValue(InitExprs[0], FieldLoc);
1736e5dd7070Spatrick } else {
1737e5dd7070Spatrick // Default-initialize to null.
1738e5dd7070Spatrick EmitNullInitializationToLValue(FieldLoc);
1739e5dd7070Spatrick }
1740e5dd7070Spatrick
1741e5dd7070Spatrick return;
1742e5dd7070Spatrick }
1743e5dd7070Spatrick
1744e5dd7070Spatrick // Here we iterate over the fields; this makes it simpler to both
1745e5dd7070Spatrick // default-initialize fields and skip over unnamed fields.
1746e5dd7070Spatrick for (const auto *field : record->fields()) {
1747e5dd7070Spatrick // We're done once we hit the flexible array member.
1748e5dd7070Spatrick if (field->getType()->isIncompleteArrayType())
1749e5dd7070Spatrick break;
1750e5dd7070Spatrick
1751e5dd7070Spatrick // Always skip anonymous bitfields.
1752e5dd7070Spatrick if (field->isUnnamedBitfield())
1753e5dd7070Spatrick continue;
1754e5dd7070Spatrick
1755e5dd7070Spatrick // We're done if we reach the end of the explicit initializers, we
1756e5dd7070Spatrick // have a zeroed object, and the rest of the fields are
1757e5dd7070Spatrick // zero-initializable.
1758e5dd7070Spatrick if (curInitIndex == NumInitElements && Dest.isZeroed() &&
1759*12c85518Srobert CGF.getTypes().isZeroInitializable(ExprToVisit->getType()))
1760e5dd7070Spatrick break;
1761e5dd7070Spatrick
1762e5dd7070Spatrick
1763e5dd7070Spatrick LValue LV = CGF.EmitLValueForFieldInitialization(DestLV, field);
1764e5dd7070Spatrick // We never generate write-barries for initialized fields.
1765e5dd7070Spatrick LV.setNonGC(true);
1766e5dd7070Spatrick
1767e5dd7070Spatrick if (curInitIndex < NumInitElements) {
1768e5dd7070Spatrick // Store the initializer into the field.
1769*12c85518Srobert EmitInitializationToLValue(InitExprs[curInitIndex++], LV);
1770e5dd7070Spatrick } else {
1771e5dd7070Spatrick // We're out of initializers; default-initialize to null
1772e5dd7070Spatrick EmitNullInitializationToLValue(LV);
1773e5dd7070Spatrick }
1774e5dd7070Spatrick
1775e5dd7070Spatrick // Push a destructor if necessary.
1776e5dd7070Spatrick // FIXME: if we have an array of structures, all explicitly
1777e5dd7070Spatrick // initialized, we can end up pushing a linear number of cleanups.
1778e5dd7070Spatrick bool pushedCleanup = false;
1779e5dd7070Spatrick if (QualType::DestructionKind dtorKind
1780e5dd7070Spatrick = field->getType().isDestructedType()) {
1781e5dd7070Spatrick assert(LV.isSimple());
1782e5dd7070Spatrick if (CGF.needsEHCleanup(dtorKind)) {
1783e5dd7070Spatrick CGF.pushDestroy(EHCleanup, LV.getAddress(CGF), field->getType(),
1784e5dd7070Spatrick CGF.getDestroyer(dtorKind), false);
1785e5dd7070Spatrick addCleanup(CGF.EHStack.stable_begin());
1786e5dd7070Spatrick pushedCleanup = true;
1787e5dd7070Spatrick }
1788e5dd7070Spatrick }
1789e5dd7070Spatrick
1790e5dd7070Spatrick // If the GEP didn't get used because of a dead zero init or something
1791e5dd7070Spatrick // else, clean it up for -O0 builds and general tidiness.
1792e5dd7070Spatrick if (!pushedCleanup && LV.isSimple())
1793e5dd7070Spatrick if (llvm::GetElementPtrInst *GEP =
1794e5dd7070Spatrick dyn_cast<llvm::GetElementPtrInst>(LV.getPointer(CGF)))
1795e5dd7070Spatrick if (GEP->use_empty())
1796e5dd7070Spatrick GEP->eraseFromParent();
1797e5dd7070Spatrick }
1798e5dd7070Spatrick
1799e5dd7070Spatrick // Deactivate all the partial cleanups in reverse order, which
1800e5dd7070Spatrick // generally means popping them.
1801e5dd7070Spatrick assert((cleanupDominator || cleanups.empty()) &&
1802e5dd7070Spatrick "Missing cleanupDominator before deactivating cleanup blocks");
1803e5dd7070Spatrick for (unsigned i = cleanups.size(); i != 0; --i)
1804e5dd7070Spatrick CGF.DeactivateCleanupBlock(cleanups[i-1], cleanupDominator);
1805e5dd7070Spatrick
1806e5dd7070Spatrick // Destroy the placeholder if we made one.
1807e5dd7070Spatrick if (cleanupDominator)
1808e5dd7070Spatrick cleanupDominator->eraseFromParent();
1809e5dd7070Spatrick }
1810e5dd7070Spatrick
VisitArrayInitLoopExpr(const ArrayInitLoopExpr * E,llvm::Value * outerBegin)1811e5dd7070Spatrick void AggExprEmitter::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E,
1812e5dd7070Spatrick llvm::Value *outerBegin) {
1813e5dd7070Spatrick // Emit the common subexpression.
1814e5dd7070Spatrick CodeGenFunction::OpaqueValueMapping binding(CGF, E->getCommonExpr());
1815e5dd7070Spatrick
1816e5dd7070Spatrick Address destPtr = EnsureSlot(E->getType()).getAddress();
1817e5dd7070Spatrick uint64_t numElements = E->getArraySize().getZExtValue();
1818e5dd7070Spatrick
1819e5dd7070Spatrick if (!numElements)
1820e5dd7070Spatrick return;
1821e5dd7070Spatrick
1822e5dd7070Spatrick // destPtr is an array*. Construct an elementType* by drilling down a level.
1823e5dd7070Spatrick llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, 0);
1824e5dd7070Spatrick llvm::Value *indices[] = {zero, zero};
1825a9ac8606Spatrick llvm::Value *begin = Builder.CreateInBoundsGEP(
1826a9ac8606Spatrick destPtr.getElementType(), destPtr.getPointer(), indices,
1827e5dd7070Spatrick "arrayinit.begin");
1828e5dd7070Spatrick
1829e5dd7070Spatrick // Prepare to special-case multidimensional array initialization: we avoid
1830e5dd7070Spatrick // emitting multiple destructor loops in that case.
1831e5dd7070Spatrick if (!outerBegin)
1832e5dd7070Spatrick outerBegin = begin;
1833e5dd7070Spatrick ArrayInitLoopExpr *InnerLoop = dyn_cast<ArrayInitLoopExpr>(E->getSubExpr());
1834e5dd7070Spatrick
1835e5dd7070Spatrick QualType elementType =
1836e5dd7070Spatrick CGF.getContext().getAsArrayType(E->getType())->getElementType();
1837e5dd7070Spatrick CharUnits elementSize = CGF.getContext().getTypeSizeInChars(elementType);
1838e5dd7070Spatrick CharUnits elementAlign =
1839e5dd7070Spatrick destPtr.getAlignment().alignmentOfArrayElement(elementSize);
1840*12c85518Srobert llvm::Type *llvmElementType = CGF.ConvertTypeForMem(elementType);
1841e5dd7070Spatrick
1842e5dd7070Spatrick llvm::BasicBlock *entryBB = Builder.GetInsertBlock();
1843e5dd7070Spatrick llvm::BasicBlock *bodyBB = CGF.createBasicBlock("arrayinit.body");
1844e5dd7070Spatrick
1845e5dd7070Spatrick // Jump into the body.
1846e5dd7070Spatrick CGF.EmitBlock(bodyBB);
1847e5dd7070Spatrick llvm::PHINode *index =
1848e5dd7070Spatrick Builder.CreatePHI(zero->getType(), 2, "arrayinit.index");
1849e5dd7070Spatrick index->addIncoming(zero, entryBB);
1850*12c85518Srobert llvm::Value *element =
1851*12c85518Srobert Builder.CreateInBoundsGEP(llvmElementType, begin, index);
1852e5dd7070Spatrick
1853e5dd7070Spatrick // Prepare for a cleanup.
1854e5dd7070Spatrick QualType::DestructionKind dtorKind = elementType.isDestructedType();
1855e5dd7070Spatrick EHScopeStack::stable_iterator cleanup;
1856e5dd7070Spatrick if (CGF.needsEHCleanup(dtorKind) && !InnerLoop) {
1857e5dd7070Spatrick if (outerBegin->getType() != element->getType())
1858e5dd7070Spatrick outerBegin = Builder.CreateBitCast(outerBegin, element->getType());
1859e5dd7070Spatrick CGF.pushRegularPartialArrayCleanup(outerBegin, element, elementType,
1860e5dd7070Spatrick elementAlign,
1861e5dd7070Spatrick CGF.getDestroyer(dtorKind));
1862e5dd7070Spatrick cleanup = CGF.EHStack.stable_begin();
1863e5dd7070Spatrick } else {
1864e5dd7070Spatrick dtorKind = QualType::DK_none;
1865e5dd7070Spatrick }
1866e5dd7070Spatrick
1867e5dd7070Spatrick // Emit the actual filler expression.
1868e5dd7070Spatrick {
1869e5dd7070Spatrick // Temporaries created in an array initialization loop are destroyed
1870e5dd7070Spatrick // at the end of each iteration.
1871e5dd7070Spatrick CodeGenFunction::RunCleanupsScope CleanupsScope(CGF);
1872e5dd7070Spatrick CodeGenFunction::ArrayInitLoopExprScope Scope(CGF, index);
1873*12c85518Srobert LValue elementLV = CGF.MakeAddrLValue(
1874*12c85518Srobert Address(element, llvmElementType, elementAlign), elementType);
1875e5dd7070Spatrick
1876e5dd7070Spatrick if (InnerLoop) {
1877e5dd7070Spatrick // If the subexpression is an ArrayInitLoopExpr, share its cleanup.
1878e5dd7070Spatrick auto elementSlot = AggValueSlot::forLValue(
1879e5dd7070Spatrick elementLV, CGF, AggValueSlot::IsDestructed,
1880e5dd7070Spatrick AggValueSlot::DoesNotNeedGCBarriers, AggValueSlot::IsNotAliased,
1881e5dd7070Spatrick AggValueSlot::DoesNotOverlap);
1882e5dd7070Spatrick AggExprEmitter(CGF, elementSlot, false)
1883e5dd7070Spatrick .VisitArrayInitLoopExpr(InnerLoop, outerBegin);
1884e5dd7070Spatrick } else
1885e5dd7070Spatrick EmitInitializationToLValue(E->getSubExpr(), elementLV);
1886e5dd7070Spatrick }
1887e5dd7070Spatrick
1888e5dd7070Spatrick // Move on to the next element.
1889e5dd7070Spatrick llvm::Value *nextIndex = Builder.CreateNUWAdd(
1890e5dd7070Spatrick index, llvm::ConstantInt::get(CGF.SizeTy, 1), "arrayinit.next");
1891e5dd7070Spatrick index->addIncoming(nextIndex, Builder.GetInsertBlock());
1892e5dd7070Spatrick
1893e5dd7070Spatrick // Leave the loop if we're done.
1894e5dd7070Spatrick llvm::Value *done = Builder.CreateICmpEQ(
1895e5dd7070Spatrick nextIndex, llvm::ConstantInt::get(CGF.SizeTy, numElements),
1896e5dd7070Spatrick "arrayinit.done");
1897e5dd7070Spatrick llvm::BasicBlock *endBB = CGF.createBasicBlock("arrayinit.end");
1898e5dd7070Spatrick Builder.CreateCondBr(done, endBB, bodyBB);
1899e5dd7070Spatrick
1900e5dd7070Spatrick CGF.EmitBlock(endBB);
1901e5dd7070Spatrick
1902e5dd7070Spatrick // Leave the partial-array cleanup if we entered one.
1903e5dd7070Spatrick if (dtorKind)
1904e5dd7070Spatrick CGF.DeactivateCleanupBlock(cleanup, index);
1905e5dd7070Spatrick }
1906e5dd7070Spatrick
VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr * E)1907e5dd7070Spatrick void AggExprEmitter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
1908e5dd7070Spatrick AggValueSlot Dest = EnsureSlot(E->getType());
1909e5dd7070Spatrick
1910e5dd7070Spatrick LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType());
1911e5dd7070Spatrick EmitInitializationToLValue(E->getBase(), DestLV);
1912e5dd7070Spatrick VisitInitListExpr(E->getUpdater());
1913e5dd7070Spatrick }
1914e5dd7070Spatrick
1915e5dd7070Spatrick //===----------------------------------------------------------------------===//
1916e5dd7070Spatrick // Entry Points into this File
1917e5dd7070Spatrick //===----------------------------------------------------------------------===//
1918e5dd7070Spatrick
1919e5dd7070Spatrick /// GetNumNonZeroBytesInInit - Get an approximate count of the number of
1920e5dd7070Spatrick /// non-zero bytes that will be stored when outputting the initializer for the
1921e5dd7070Spatrick /// specified initializer expression.
GetNumNonZeroBytesInInit(const Expr * E,CodeGenFunction & CGF)1922e5dd7070Spatrick static CharUnits GetNumNonZeroBytesInInit(const Expr *E, CodeGenFunction &CGF) {
1923a9ac8606Spatrick if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E))
1924a9ac8606Spatrick E = MTE->getSubExpr();
1925a9ac8606Spatrick E = E->IgnoreParenNoopCasts(CGF.getContext());
1926e5dd7070Spatrick
1927e5dd7070Spatrick // 0 and 0.0 won't require any non-zero stores!
1928e5dd7070Spatrick if (isSimpleZero(E, CGF)) return CharUnits::Zero();
1929e5dd7070Spatrick
1930e5dd7070Spatrick // If this is an initlist expr, sum up the size of sizes of the (present)
1931e5dd7070Spatrick // elements. If this is something weird, assume the whole thing is non-zero.
1932e5dd7070Spatrick const InitListExpr *ILE = dyn_cast<InitListExpr>(E);
1933e5dd7070Spatrick while (ILE && ILE->isTransparent())
1934e5dd7070Spatrick ILE = dyn_cast<InitListExpr>(ILE->getInit(0));
1935e5dd7070Spatrick if (!ILE || !CGF.getTypes().isZeroInitializable(ILE->getType()))
1936e5dd7070Spatrick return CGF.getContext().getTypeSizeInChars(E->getType());
1937e5dd7070Spatrick
1938e5dd7070Spatrick // InitListExprs for structs have to be handled carefully. If there are
1939e5dd7070Spatrick // reference members, we need to consider the size of the reference, not the
1940e5dd7070Spatrick // referencee. InitListExprs for unions and arrays can't have references.
1941e5dd7070Spatrick if (const RecordType *RT = E->getType()->getAs<RecordType>()) {
1942e5dd7070Spatrick if (!RT->isUnionType()) {
1943e5dd7070Spatrick RecordDecl *SD = RT->getDecl();
1944e5dd7070Spatrick CharUnits NumNonZeroBytes = CharUnits::Zero();
1945e5dd7070Spatrick
1946e5dd7070Spatrick unsigned ILEElement = 0;
1947e5dd7070Spatrick if (auto *CXXRD = dyn_cast<CXXRecordDecl>(SD))
1948e5dd7070Spatrick while (ILEElement != CXXRD->getNumBases())
1949e5dd7070Spatrick NumNonZeroBytes +=
1950e5dd7070Spatrick GetNumNonZeroBytesInInit(ILE->getInit(ILEElement++), CGF);
1951e5dd7070Spatrick for (const auto *Field : SD->fields()) {
1952e5dd7070Spatrick // We're done once we hit the flexible array member or run out of
1953e5dd7070Spatrick // InitListExpr elements.
1954e5dd7070Spatrick if (Field->getType()->isIncompleteArrayType() ||
1955e5dd7070Spatrick ILEElement == ILE->getNumInits())
1956e5dd7070Spatrick break;
1957e5dd7070Spatrick if (Field->isUnnamedBitfield())
1958e5dd7070Spatrick continue;
1959e5dd7070Spatrick
1960e5dd7070Spatrick const Expr *E = ILE->getInit(ILEElement++);
1961e5dd7070Spatrick
1962e5dd7070Spatrick // Reference values are always non-null and have the width of a pointer.
1963e5dd7070Spatrick if (Field->getType()->isReferenceType())
1964e5dd7070Spatrick NumNonZeroBytes += CGF.getContext().toCharUnitsFromBits(
1965*12c85518Srobert CGF.getTarget().getPointerWidth(LangAS::Default));
1966e5dd7070Spatrick else
1967e5dd7070Spatrick NumNonZeroBytes += GetNumNonZeroBytesInInit(E, CGF);
1968e5dd7070Spatrick }
1969e5dd7070Spatrick
1970e5dd7070Spatrick return NumNonZeroBytes;
1971e5dd7070Spatrick }
1972e5dd7070Spatrick }
1973e5dd7070Spatrick
1974a9ac8606Spatrick // FIXME: This overestimates the number of non-zero bytes for bit-fields.
1975e5dd7070Spatrick CharUnits NumNonZeroBytes = CharUnits::Zero();
1976e5dd7070Spatrick for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i)
1977e5dd7070Spatrick NumNonZeroBytes += GetNumNonZeroBytesInInit(ILE->getInit(i), CGF);
1978e5dd7070Spatrick return NumNonZeroBytes;
1979e5dd7070Spatrick }
1980e5dd7070Spatrick
1981e5dd7070Spatrick /// CheckAggExprForMemSetUse - If the initializer is large and has a lot of
1982e5dd7070Spatrick /// zeros in it, emit a memset and avoid storing the individual zeros.
1983e5dd7070Spatrick ///
CheckAggExprForMemSetUse(AggValueSlot & Slot,const Expr * E,CodeGenFunction & CGF)1984e5dd7070Spatrick static void CheckAggExprForMemSetUse(AggValueSlot &Slot, const Expr *E,
1985e5dd7070Spatrick CodeGenFunction &CGF) {
1986e5dd7070Spatrick // If the slot is already known to be zeroed, nothing to do. Don't mess with
1987e5dd7070Spatrick // volatile stores.
1988e5dd7070Spatrick if (Slot.isZeroed() || Slot.isVolatile() || !Slot.getAddress().isValid())
1989e5dd7070Spatrick return;
1990e5dd7070Spatrick
1991e5dd7070Spatrick // C++ objects with a user-declared constructor don't need zero'ing.
1992e5dd7070Spatrick if (CGF.getLangOpts().CPlusPlus)
1993e5dd7070Spatrick if (const RecordType *RT = CGF.getContext()
1994e5dd7070Spatrick .getBaseElementType(E->getType())->getAs<RecordType>()) {
1995e5dd7070Spatrick const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1996e5dd7070Spatrick if (RD->hasUserDeclaredConstructor())
1997e5dd7070Spatrick return;
1998e5dd7070Spatrick }
1999e5dd7070Spatrick
2000e5dd7070Spatrick // If the type is 16-bytes or smaller, prefer individual stores over memset.
2001e5dd7070Spatrick CharUnits Size = Slot.getPreferredSize(CGF.getContext(), E->getType());
2002e5dd7070Spatrick if (Size <= CharUnits::fromQuantity(16))
2003e5dd7070Spatrick return;
2004e5dd7070Spatrick
2005e5dd7070Spatrick // Check to see if over 3/4 of the initializer are known to be zero. If so,
2006e5dd7070Spatrick // we prefer to emit memset + individual stores for the rest.
2007e5dd7070Spatrick CharUnits NumNonZeroBytes = GetNumNonZeroBytesInInit(E, CGF);
2008e5dd7070Spatrick if (NumNonZeroBytes*4 > Size)
2009e5dd7070Spatrick return;
2010e5dd7070Spatrick
2011e5dd7070Spatrick // Okay, it seems like a good idea to use an initial memset, emit the call.
2012e5dd7070Spatrick llvm::Constant *SizeVal = CGF.Builder.getInt64(Size.getQuantity());
2013e5dd7070Spatrick
2014e5dd7070Spatrick Address Loc = Slot.getAddress();
2015e5dd7070Spatrick Loc = CGF.Builder.CreateElementBitCast(Loc, CGF.Int8Ty);
2016e5dd7070Spatrick CGF.Builder.CreateMemSet(Loc, CGF.Builder.getInt8(0), SizeVal, false);
2017e5dd7070Spatrick
2018e5dd7070Spatrick // Tell the AggExprEmitter that the slot is known zero.
2019e5dd7070Spatrick Slot.setZeroed();
2020e5dd7070Spatrick }
2021e5dd7070Spatrick
2022e5dd7070Spatrick
2023e5dd7070Spatrick
2024e5dd7070Spatrick
2025e5dd7070Spatrick /// EmitAggExpr - Emit the computation of the specified expression of aggregate
2026e5dd7070Spatrick /// type. The result is computed into DestPtr. Note that if DestPtr is null,
2027e5dd7070Spatrick /// the value of the aggregate expression is not needed. If VolatileDest is
2028e5dd7070Spatrick /// true, DestPtr cannot be 0.
EmitAggExpr(const Expr * E,AggValueSlot Slot)2029e5dd7070Spatrick void CodeGenFunction::EmitAggExpr(const Expr *E, AggValueSlot Slot) {
2030e5dd7070Spatrick assert(E && hasAggregateEvaluationKind(E->getType()) &&
2031e5dd7070Spatrick "Invalid aggregate expression to emit");
2032e5dd7070Spatrick assert((Slot.getAddress().isValid() || Slot.isIgnored()) &&
2033e5dd7070Spatrick "slot has bits but no address");
2034e5dd7070Spatrick
2035e5dd7070Spatrick // Optimize the slot if possible.
2036e5dd7070Spatrick CheckAggExprForMemSetUse(Slot, E, *this);
2037e5dd7070Spatrick
2038e5dd7070Spatrick AggExprEmitter(*this, Slot, Slot.isIgnored()).Visit(const_cast<Expr*>(E));
2039e5dd7070Spatrick }
2040e5dd7070Spatrick
EmitAggExprToLValue(const Expr * E)2041e5dd7070Spatrick LValue CodeGenFunction::EmitAggExprToLValue(const Expr *E) {
2042e5dd7070Spatrick assert(hasAggregateEvaluationKind(E->getType()) && "Invalid argument!");
2043e5dd7070Spatrick Address Temp = CreateMemTemp(E->getType());
2044e5dd7070Spatrick LValue LV = MakeAddrLValue(Temp, E->getType());
2045e5dd7070Spatrick EmitAggExpr(E, AggValueSlot::forLValue(
2046e5dd7070Spatrick LV, *this, AggValueSlot::IsNotDestructed,
2047e5dd7070Spatrick AggValueSlot::DoesNotNeedGCBarriers,
2048e5dd7070Spatrick AggValueSlot::IsNotAliased, AggValueSlot::DoesNotOverlap));
2049e5dd7070Spatrick return LV;
2050e5dd7070Spatrick }
2051e5dd7070Spatrick
2052e5dd7070Spatrick AggValueSlot::Overlap_t
getOverlapForFieldInit(const FieldDecl * FD)2053e5dd7070Spatrick CodeGenFunction::getOverlapForFieldInit(const FieldDecl *FD) {
2054e5dd7070Spatrick if (!FD->hasAttr<NoUniqueAddressAttr>() || !FD->getType()->isRecordType())
2055e5dd7070Spatrick return AggValueSlot::DoesNotOverlap;
2056e5dd7070Spatrick
2057e5dd7070Spatrick // If the field lies entirely within the enclosing class's nvsize, its tail
2058e5dd7070Spatrick // padding cannot overlap any already-initialized object. (The only subobjects
2059e5dd7070Spatrick // with greater addresses that might already be initialized are vbases.)
2060e5dd7070Spatrick const RecordDecl *ClassRD = FD->getParent();
2061e5dd7070Spatrick const ASTRecordLayout &Layout = getContext().getASTRecordLayout(ClassRD);
2062e5dd7070Spatrick if (Layout.getFieldOffset(FD->getFieldIndex()) +
2063e5dd7070Spatrick getContext().getTypeSize(FD->getType()) <=
2064e5dd7070Spatrick (uint64_t)getContext().toBits(Layout.getNonVirtualSize()))
2065e5dd7070Spatrick return AggValueSlot::DoesNotOverlap;
2066e5dd7070Spatrick
2067e5dd7070Spatrick // The tail padding may contain values we need to preserve.
2068e5dd7070Spatrick return AggValueSlot::MayOverlap;
2069e5dd7070Spatrick }
2070e5dd7070Spatrick
getOverlapForBaseInit(const CXXRecordDecl * RD,const CXXRecordDecl * BaseRD,bool IsVirtual)2071e5dd7070Spatrick AggValueSlot::Overlap_t CodeGenFunction::getOverlapForBaseInit(
2072e5dd7070Spatrick const CXXRecordDecl *RD, const CXXRecordDecl *BaseRD, bool IsVirtual) {
2073e5dd7070Spatrick // If the most-derived object is a field declared with [[no_unique_address]],
2074e5dd7070Spatrick // the tail padding of any virtual base could be reused for other subobjects
2075e5dd7070Spatrick // of that field's class.
2076e5dd7070Spatrick if (IsVirtual)
2077e5dd7070Spatrick return AggValueSlot::MayOverlap;
2078e5dd7070Spatrick
2079e5dd7070Spatrick // If the base class is laid out entirely within the nvsize of the derived
2080e5dd7070Spatrick // class, its tail padding cannot yet be initialized, so we can issue
2081e5dd7070Spatrick // stores at the full width of the base class.
2082e5dd7070Spatrick const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD);
2083e5dd7070Spatrick if (Layout.getBaseClassOffset(BaseRD) +
2084e5dd7070Spatrick getContext().getASTRecordLayout(BaseRD).getSize() <=
2085e5dd7070Spatrick Layout.getNonVirtualSize())
2086e5dd7070Spatrick return AggValueSlot::DoesNotOverlap;
2087e5dd7070Spatrick
2088e5dd7070Spatrick // The tail padding may contain values we need to preserve.
2089e5dd7070Spatrick return AggValueSlot::MayOverlap;
2090e5dd7070Spatrick }
2091e5dd7070Spatrick
EmitAggregateCopy(LValue Dest,LValue Src,QualType Ty,AggValueSlot::Overlap_t MayOverlap,bool isVolatile)2092e5dd7070Spatrick void CodeGenFunction::EmitAggregateCopy(LValue Dest, LValue Src, QualType Ty,
2093e5dd7070Spatrick AggValueSlot::Overlap_t MayOverlap,
2094e5dd7070Spatrick bool isVolatile) {
2095e5dd7070Spatrick assert(!Ty->isAnyComplexType() && "Shouldn't happen for complex");
2096e5dd7070Spatrick
2097e5dd7070Spatrick Address DestPtr = Dest.getAddress(*this);
2098e5dd7070Spatrick Address SrcPtr = Src.getAddress(*this);
2099e5dd7070Spatrick
2100e5dd7070Spatrick if (getLangOpts().CPlusPlus) {
2101e5dd7070Spatrick if (const RecordType *RT = Ty->getAs<RecordType>()) {
2102e5dd7070Spatrick CXXRecordDecl *Record = cast<CXXRecordDecl>(RT->getDecl());
2103e5dd7070Spatrick assert((Record->hasTrivialCopyConstructor() ||
2104e5dd7070Spatrick Record->hasTrivialCopyAssignment() ||
2105e5dd7070Spatrick Record->hasTrivialMoveConstructor() ||
2106e5dd7070Spatrick Record->hasTrivialMoveAssignment() ||
2107a9ac8606Spatrick Record->hasAttr<TrivialABIAttr>() || Record->isUnion()) &&
2108e5dd7070Spatrick "Trying to aggregate-copy a type without a trivial copy/move "
2109e5dd7070Spatrick "constructor or assignment operator");
2110e5dd7070Spatrick // Ignore empty classes in C++.
2111e5dd7070Spatrick if (Record->isEmpty())
2112e5dd7070Spatrick return;
2113e5dd7070Spatrick }
2114e5dd7070Spatrick }
2115e5dd7070Spatrick
2116ec727ea7Spatrick if (getLangOpts().CUDAIsDevice) {
2117ec727ea7Spatrick if (Ty->isCUDADeviceBuiltinSurfaceType()) {
2118ec727ea7Spatrick if (getTargetHooks().emitCUDADeviceBuiltinSurfaceDeviceCopy(*this, Dest,
2119ec727ea7Spatrick Src))
2120ec727ea7Spatrick return;
2121ec727ea7Spatrick } else if (Ty->isCUDADeviceBuiltinTextureType()) {
2122ec727ea7Spatrick if (getTargetHooks().emitCUDADeviceBuiltinTextureDeviceCopy(*this, Dest,
2123ec727ea7Spatrick Src))
2124ec727ea7Spatrick return;
2125ec727ea7Spatrick }
2126ec727ea7Spatrick }
2127ec727ea7Spatrick
2128e5dd7070Spatrick // Aggregate assignment turns into llvm.memcpy. This is almost valid per
2129e5dd7070Spatrick // C99 6.5.16.1p3, which states "If the value being stored in an object is
2130e5dd7070Spatrick // read from another object that overlaps in anyway the storage of the first
2131e5dd7070Spatrick // object, then the overlap shall be exact and the two objects shall have
2132e5dd7070Spatrick // qualified or unqualified versions of a compatible type."
2133e5dd7070Spatrick //
2134e5dd7070Spatrick // memcpy is not defined if the source and destination pointers are exactly
2135e5dd7070Spatrick // equal, but other compilers do this optimization, and almost every memcpy
2136e5dd7070Spatrick // implementation handles this case safely. If there is a libc that does not
2137e5dd7070Spatrick // safely handle this, we can add a target hook.
2138e5dd7070Spatrick
2139e5dd7070Spatrick // Get data size info for this aggregate. Don't copy the tail padding if this
2140e5dd7070Spatrick // might be a potentially-overlapping subobject, since the tail padding might
2141e5dd7070Spatrick // be occupied by a different object. Otherwise, copying it is fine.
2142a9ac8606Spatrick TypeInfoChars TypeInfo;
2143e5dd7070Spatrick if (MayOverlap)
2144e5dd7070Spatrick TypeInfo = getContext().getTypeInfoDataSizeInChars(Ty);
2145e5dd7070Spatrick else
2146e5dd7070Spatrick TypeInfo = getContext().getTypeInfoInChars(Ty);
2147e5dd7070Spatrick
2148e5dd7070Spatrick llvm::Value *SizeVal = nullptr;
2149a9ac8606Spatrick if (TypeInfo.Width.isZero()) {
2150e5dd7070Spatrick // But note that getTypeInfo returns 0 for a VLA.
2151e5dd7070Spatrick if (auto *VAT = dyn_cast_or_null<VariableArrayType>(
2152e5dd7070Spatrick getContext().getAsArrayType(Ty))) {
2153e5dd7070Spatrick QualType BaseEltTy;
2154e5dd7070Spatrick SizeVal = emitArrayLength(VAT, BaseEltTy, DestPtr);
2155e5dd7070Spatrick TypeInfo = getContext().getTypeInfoInChars(BaseEltTy);
2156a9ac8606Spatrick assert(!TypeInfo.Width.isZero());
2157e5dd7070Spatrick SizeVal = Builder.CreateNUWMul(
2158e5dd7070Spatrick SizeVal,
2159a9ac8606Spatrick llvm::ConstantInt::get(SizeTy, TypeInfo.Width.getQuantity()));
2160e5dd7070Spatrick }
2161e5dd7070Spatrick }
2162e5dd7070Spatrick if (!SizeVal) {
2163a9ac8606Spatrick SizeVal = llvm::ConstantInt::get(SizeTy, TypeInfo.Width.getQuantity());
2164e5dd7070Spatrick }
2165e5dd7070Spatrick
2166e5dd7070Spatrick // FIXME: If we have a volatile struct, the optimizer can remove what might
2167e5dd7070Spatrick // appear to be `extra' memory ops:
2168e5dd7070Spatrick //
2169e5dd7070Spatrick // volatile struct { int i; } a, b;
2170e5dd7070Spatrick //
2171e5dd7070Spatrick // int main() {
2172e5dd7070Spatrick // a = b;
2173e5dd7070Spatrick // a = b;
2174e5dd7070Spatrick // }
2175e5dd7070Spatrick //
2176e5dd7070Spatrick // we need to use a different call here. We use isVolatile to indicate when
2177e5dd7070Spatrick // either the source or the destination is volatile.
2178e5dd7070Spatrick
2179e5dd7070Spatrick DestPtr = Builder.CreateElementBitCast(DestPtr, Int8Ty);
2180e5dd7070Spatrick SrcPtr = Builder.CreateElementBitCast(SrcPtr, Int8Ty);
2181e5dd7070Spatrick
2182e5dd7070Spatrick // Don't do any of the memmove_collectable tests if GC isn't set.
2183e5dd7070Spatrick if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
2184e5dd7070Spatrick // fall through
2185e5dd7070Spatrick } else if (const RecordType *RecordTy = Ty->getAs<RecordType>()) {
2186e5dd7070Spatrick RecordDecl *Record = RecordTy->getDecl();
2187e5dd7070Spatrick if (Record->hasObjectMember()) {
2188e5dd7070Spatrick CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr,
2189e5dd7070Spatrick SizeVal);
2190e5dd7070Spatrick return;
2191e5dd7070Spatrick }
2192e5dd7070Spatrick } else if (Ty->isArrayType()) {
2193e5dd7070Spatrick QualType BaseType = getContext().getBaseElementType(Ty);
2194e5dd7070Spatrick if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) {
2195e5dd7070Spatrick if (RecordTy->getDecl()->hasObjectMember()) {
2196e5dd7070Spatrick CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr,
2197e5dd7070Spatrick SizeVal);
2198e5dd7070Spatrick return;
2199e5dd7070Spatrick }
2200e5dd7070Spatrick }
2201e5dd7070Spatrick }
2202e5dd7070Spatrick
2203e5dd7070Spatrick auto Inst = Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, isVolatile);
2204e5dd7070Spatrick
2205e5dd7070Spatrick // Determine the metadata to describe the position of any padding in this
2206e5dd7070Spatrick // memcpy, as well as the TBAA tags for the members of the struct, in case
2207e5dd7070Spatrick // the optimizer wishes to expand it in to scalar memory operations.
2208e5dd7070Spatrick if (llvm::MDNode *TBAAStructTag = CGM.getTBAAStructInfo(Ty))
2209e5dd7070Spatrick Inst->setMetadata(llvm::LLVMContext::MD_tbaa_struct, TBAAStructTag);
2210e5dd7070Spatrick
2211e5dd7070Spatrick if (CGM.getCodeGenOpts().NewStructPathTBAA) {
2212e5dd7070Spatrick TBAAAccessInfo TBAAInfo = CGM.mergeTBAAInfoForMemoryTransfer(
2213e5dd7070Spatrick Dest.getTBAAInfo(), Src.getTBAAInfo());
2214e5dd7070Spatrick CGM.DecorateInstructionWithTBAA(Inst, TBAAInfo);
2215e5dd7070Spatrick }
2216e5dd7070Spatrick }
2217