CGExprAgg.cpp source code [clang_source_code/lib/CodeGen/CGExprAgg.cpp]

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

clang::CodeGen::CodeGenFunction::EmitAggExpr

clang::CodeGen::CodeGenFunction::EmitAggExprToLValue

clang::CodeGen::CodeGenFunction::overlapForBaseInit

clang::CodeGen::CodeGenFunction::EmitAggregateCopy

Clang Project