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

1	//===--- CGExprCXX.cpp - Emit LLVM Code for C++ 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 dealing with code generation of C++ expressions
10	//
11	//===----------------------------------------------------------------------===//
12
13	#include "CodeGenFunction.h"
14	#include "CGCUDARuntime.h"
15	#include "CGCXXABI.h"
16	#include "CGDebugInfo.h"
17	#include "CGObjCRuntime.h"
18	#include "ConstantEmitter.h"
19	#include "clang/Basic/CodeGenOptions.h"
20	#include "clang/CodeGen/CGFunctionInfo.h"
21	#include "llvm/IR/Intrinsics.h"
22
23	using namespace clang;
24	using namespace CodeGen;
25
26	namespace {
27	struct MemberCallInfo {
28	RequiredArgs ReqArgs;
29	// Number of prefix arguments for the call. Ignores the `this` pointer.
30	unsigned PrefixSize;
31	};
32	}
33
34	static MemberCallInfo
35	commonEmitCXXMemberOrOperatorCall(CodeGenFunction &CGF, const CXXMethodDecl *MD,
36	llvm::Value This, llvm::Value ImplicitParam,
37	QualType ImplicitParamTy, const CallExpr *CE,
38	CallArgList &Args, CallArgList *RtlArgs) {
39	(CE) \|\| isa(CE)", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 40, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(CE == nullptr \|\| isa<CXXMemberCallExpr>(CE) \|\|
40	(CE) \|\| isa(CE)", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 40, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> isa<CXXOperatorCallExpr>(CE));
41	(0) . __assert_fail ("MD->isInstance() && \"Trying to emit a member or operator call expr on a static method!\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 42, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(MD->isInstance() &&
42	(0) . __assert_fail ("MD->isInstance() && \"Trying to emit a member or operator call expr on a static method!\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 42, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> "Trying to emit a member or operator call expr on a static method!");
43
44	// Push the this ptr.
45	const CXXRecordDecl *RD =
46	CGF.CGM.getCXXABI().getThisArgumentTypeForMethod(MD);
47	Args.add(RValue::get(This), CGF.getTypes().DeriveThisType(RD, MD));
48
49	// If there is an implicit parameter (e.g. VTT), emit it.
50	if (ImplicitParam) {
51	Args.add(RValue::get(ImplicitParam), ImplicitParamTy);
52	}
53
54	const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
55	RequiredArgs required = RequiredArgs::forPrototypePlus(FPT, Args.size());
56	unsigned PrefixSize = Args.size() - 1;
57
58	// And the rest of the call args.
59	if (RtlArgs) {
60	// Special case: if the caller emitted the arguments right-to-left already
61	// (prior to emitting the *this argument), we're done. This happens for
62	// assignment operators.
63	Args.addFrom(*RtlArgs);
64	} else if (CE) {
65	// Special case: skip first argument of CXXOperatorCall (it is "this").
66	unsigned ArgsToSkip = isa<CXXOperatorCallExpr>(CE) ? 1 : 0;
67	CGF.EmitCallArgs(Args, FPT, drop_begin(CE->arguments(), ArgsToSkip),
68	CE->getDirectCallee());
69	} else {
70	(0) . __assert_fail ("FPT->getNumParams() == 0 && \"No CallExpr specified for function with non-zero number of arguments\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 72, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(
71	(0) . __assert_fail ("FPT->getNumParams() == 0 && \"No CallExpr specified for function with non-zero number of arguments\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 72, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> FPT->getNumParams() == 0 &&
72	(0) . __assert_fail ("FPT->getNumParams() == 0 && \"No CallExpr specified for function with non-zero number of arguments\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 72, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> "No CallExpr specified for function with non-zero number of arguments");
73	}
74	return {required, PrefixSize};
75	}
76
77	RValue CodeGenFunction::EmitCXXMemberOrOperatorCall(
78	const CXXMethodDecl *MD, const CGCallee &Callee,
79	ReturnValueSlot ReturnValue,
80	llvm::Value This, llvm::Value ImplicitParam, QualType ImplicitParamTy,
81	const CallExpr CE, CallArgList RtlArgs) {
82	const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
83	CallArgList Args;
84	MemberCallInfo CallInfo = commonEmitCXXMemberOrOperatorCall(
85	*this, MD, This, ImplicitParam, ImplicitParamTy, CE, Args, RtlArgs);
86	auto &FnInfo = CGM.getTypes().arrangeCXXMethodCall(
87	Args, FPT, CallInfo.ReqArgs, CallInfo.PrefixSize);
88	return EmitCall(FnInfo, Callee, ReturnValue, Args, nullptr,
89	CE ? CE->getExprLoc() : SourceLocation());
90	}
91
92	RValue CodeGenFunction::EmitCXXDestructorCall(
93	GlobalDecl Dtor, const CGCallee &Callee, llvm::Value *This,
94	llvm::Value ImplicitParam, QualType ImplicitParamTy, const CallExpr CE) {
95	CallArgList Args;
96	commonEmitCXXMemberOrOperatorCall(*this, cast<CXXMethodDecl>(Dtor.getDecl()),
97	This, ImplicitParam, ImplicitParamTy, CE,
98	Args, nullptr);
99	return EmitCall(CGM.getTypes().arrangeCXXStructorDeclaration(Dtor), Callee,
100	ReturnValueSlot(), Args);
101	}
102
103	RValue CodeGenFunction::EmitCXXPseudoDestructorExpr(
104	const CXXPseudoDestructorExpr *E) {
105	QualType DestroyedType = E->getDestroyedType();
106	if (DestroyedType.hasStrongOrWeakObjCLifetime()) {
107	// Automatic Reference Counting:
108	// If the pseudo-expression names a retainable object with weak or
109	// strong lifetime, the object shall be released.
110	Expr *BaseExpr = E->getBase();
111	Address BaseValue = Address::invalid();
112	Qualifiers BaseQuals;
113
114	// If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar.
115	if (E->isArrow()) {
116	BaseValue = EmitPointerWithAlignment(BaseExpr);
117	const PointerType *PTy = BaseExpr->getType()->getAs<PointerType>();
118	BaseQuals = PTy->getPointeeType().getQualifiers();
119	} else {
120	LValue BaseLV = EmitLValue(BaseExpr);
121	BaseValue = BaseLV.getAddress();
122	QualType BaseTy = BaseExpr->getType();
123	BaseQuals = BaseTy.getQualifiers();
124	}
125
126	switch (DestroyedType.getObjCLifetime()) {
127	case Qualifiers::OCL_None:
128	case Qualifiers::OCL_ExplicitNone:
129	case Qualifiers::OCL_Autoreleasing:
130	break;
131
132	case Qualifiers::OCL_Strong:
133	EmitARCRelease(Builder.CreateLoad(BaseValue,
134	DestroyedType.isVolatileQualified()),
135	ARCPreciseLifetime);
136	break;
137
138	case Qualifiers::OCL_Weak:
139	EmitARCDestroyWeak(BaseValue);
140	break;
141	}
142	} else {
143	// C++ [expr.pseudo]p1:
144	// The result shall only be used as the operand for the function call
145	// operator (), and the result of such a call has type void. The only
146	// effect is the evaluation of the postfix-expression before the dot or
147	// arrow.
148	EmitIgnoredExpr(E->getBase());
149	}
150
151	return RValue::get(nullptr);
152	}
153
154	static CXXRecordDecl getCXXRecord(const Expr E) {
155	QualType T = E->getType();
156	if (const PointerType *PTy = T->getAs<PointerType>())
157	T = PTy->getPointeeType();
158	const RecordType *Ty = T->castAs<RecordType>();
159	return cast<CXXRecordDecl>(Ty->getDecl());
160	}
161
162	// Note: This function also emit constructor calls to support a MSVC
163	// extensions allowing explicit constructor function call.
164	RValue CodeGenFunction::EmitCXXMemberCallExpr(const CXXMemberCallExpr *CE,
165	ReturnValueSlot ReturnValue) {
166	const Expr *callee = CE->getCallee()->IgnoreParens();
167
168	if (isa<BinaryOperator>(callee))
169	return EmitCXXMemberPointerCallExpr(CE, ReturnValue);
170
171	const MemberExpr *ME = cast<MemberExpr>(callee);
172	const CXXMethodDecl *MD = cast<CXXMethodDecl>(ME->getMemberDecl());
173
174	if (MD->isStatic()) {
175	// The method is static, emit it as we would a regular call.
176	CGCallee callee =
177	CGCallee::forDirect(CGM.GetAddrOfFunction(MD), GlobalDecl(MD));
178	return EmitCall(getContext().getPointerType(MD->getType()), callee, CE,
179	ReturnValue);
180	}
181
182	bool HasQualifier = ME->hasQualifier();
183	NestedNameSpecifier *Qualifier = HasQualifier ? ME->getQualifier() : nullptr;
184	bool IsArrow = ME->isArrow();
185	const Expr *Base = ME->getBase();
186
187	return EmitCXXMemberOrOperatorMemberCallExpr(
188	CE, MD, ReturnValue, HasQualifier, Qualifier, IsArrow, Base);
189	}
190
191	RValue CodeGenFunction::EmitCXXMemberOrOperatorMemberCallExpr(
192	const CallExpr CE, const CXXMethodDecl MD, ReturnValueSlot ReturnValue,
193	bool HasQualifier, NestedNameSpecifier *Qualifier, bool IsArrow,
194	const Expr *Base) {
195	(CE) \|\| isa(CE)", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 195, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(isa<CXXMemberCallExpr>(CE) \|\| isa<CXXOperatorCallExpr>(CE));
196
197	// Compute the object pointer.
198	bool CanUseVirtualCall = MD->isVirtual() && !HasQualifier;
199
200	const CXXMethodDecl *DevirtualizedMethod = nullptr;
201	if (CanUseVirtualCall &&
202	MD->getDevirtualizedMethod(Base, getLangOpts().AppleKext)) {
203	const CXXRecordDecl *BestDynamicDecl = Base->getBestDynamicClassType();
204	DevirtualizedMethod = MD->getCorrespondingMethodInClass(BestDynamicDecl);
205	assert(DevirtualizedMethod);
206	const CXXRecordDecl *DevirtualizedClass = DevirtualizedMethod->getParent();
207	const Expr *Inner = Base->ignoreParenBaseCasts();
208	if (DevirtualizedMethod->getReturnType().getCanonicalType() !=
209	MD->getReturnType().getCanonicalType())
210	// If the return types are not the same, this might be a case where more
211	// code needs to run to compensate for it. For example, the derived
212	// method might return a type that inherits form from the return
213	// type of MD and has a prefix.
214	// For now we just avoid devirtualizing these covariant cases.
215	DevirtualizedMethod = nullptr;
216	else if (getCXXRecord(Inner) == DevirtualizedClass)
217	// If the class of the Inner expression is where the dynamic method
218	// is defined, build the this pointer from it.
219	Base = Inner;
220	else if (getCXXRecord(Base) != DevirtualizedClass) {
221	// If the method is defined in a class that is not the best dynamic
222	// one or the one of the full expression, we would have to build
223	// a derived-to-base cast to compute the correct this pointer, but
224	// we don't have support for that yet, so do a virtual call.
225	DevirtualizedMethod = nullptr;
226	}
227	}
228
229	// C++17 demands that we evaluate the RHS of a (possibly-compound) assignment
230	// operator before the LHS.
231	CallArgList RtlArgStorage;
232	CallArgList *RtlArgs = nullptr;
233	if (auto *OCE = dyn_cast<CXXOperatorCallExpr>(CE)) {
234	if (OCE->isAssignmentOp()) {
235	RtlArgs = &RtlArgStorage;
236	EmitCallArgs(*RtlArgs, MD->getType()->castAs<FunctionProtoType>(),
237	drop_begin(CE->arguments(), 1), CE->getDirectCallee(),
238	/ParamsToSkip/0, EvaluationOrder::ForceRightToLeft);
239	}
240	}
241
242	LValue This;
243	if (IsArrow) {
244	LValueBaseInfo BaseInfo;
245	TBAAAccessInfo TBAAInfo;
246	Address ThisValue = EmitPointerWithAlignment(Base, &BaseInfo, &TBAAInfo);
247	This = MakeAddrLValue(ThisValue, Base->getType(), BaseInfo, TBAAInfo);
248	} else {
249	This = EmitLValue(Base);
250	}
251
252	if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) {
253	// This is the MSVC p->Ctor::Ctor(...) extension. We assume that's
254	// constructing a new complete object of type Ctor.
255	assert(!RtlArgs);
256	(0) . __assert_fail ("ReturnValue.isNull() && \"Constructor shouldn't have return value\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 256, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(ReturnValue.isNull() && "Constructor shouldn't have return value");
257	CallArgList Args;
258	commonEmitCXXMemberOrOperatorCall(
259	this, Ctor, This.getPointer(), /ImplicitParam=*/nullptr,
260	/ImplicitParamTy=/QualType(), CE, Args, nullptr);
261
262	EmitCXXConstructorCall(Ctor, Ctor_Complete, /ForVirtualBase=/false,
263	/Delegating=/false, This.getAddress(), Args,
264	AggValueSlot::DoesNotOverlap, CE->getExprLoc(),
265	/NewPointerIsChecked=/false);
266	return RValue::get(nullptr);
267	}
268
269	if (MD->isTrivial() \|\| (MD->isDefaulted() && MD->getParent()->isUnion())) {
270	if (isa<CXXDestructorDecl>(MD)) return RValue::get(nullptr);
271	if (!MD->getParent()->mayInsertExtraPadding()) {
272	if (MD->isCopyAssignmentOperator() \|\| MD->isMoveAssignmentOperator()) {
273	// We don't like to generate the trivial copy/move assignment operator
274	// when it isn't necessary; just produce the proper effect here.
275	LValue RHS = isa<CXXOperatorCallExpr>(CE)
276	? MakeNaturalAlignAddrLValue(
277	(RtlArgs)[0].getRValue(this).getScalarVal(),
278	(*(CE->arg_begin() + 1))->getType())
279	: EmitLValue(*CE->arg_begin());
280	EmitAggregateAssign(This, RHS, CE->getType());
281	return RValue::get(This.getPointer());
282	}
283	llvm_unreachable("unknown trivial member function");
284	}
285	}
286
287	// Compute the function type we're calling.
288	const CXXMethodDecl *CalleeDecl =
289	DevirtualizedMethod ? DevirtualizedMethod : MD;
290	const CGFunctionInfo *FInfo = nullptr;
291	if (const auto *Dtor = dyn_cast<CXXDestructorDecl>(CalleeDecl))
292	FInfo = &CGM.getTypes().arrangeCXXStructorDeclaration(
293	GlobalDecl(Dtor, Dtor_Complete));
294	else
295	FInfo = &CGM.getTypes().arrangeCXXMethodDeclaration(CalleeDecl);
296
297	llvm::FunctionType Ty = CGM.getTypes().GetFunctionType(FInfo);
298
299	// C++11 [class.mfct.non-static]p2:
300	// If a non-static member function of a class X is called for an object that
301	// is not of type X, or of a type derived from X, the behavior is undefined.
302	SourceLocation CallLoc;
303	ASTContext &C = getContext();
304	if (CE)
305	CallLoc = CE->getExprLoc();
306
307	SanitizerSet SkippedChecks;
308	if (const auto *CMCE = dyn_cast<CXXMemberCallExpr>(CE)) {
309	auto *IOA = CMCE->getImplicitObjectArgument();
310	bool IsImplicitObjectCXXThis = IsWrappedCXXThis(IOA);
311	if (IsImplicitObjectCXXThis)
312	SkippedChecks.set(SanitizerKind::Alignment, true);
313	if (IsImplicitObjectCXXThis \|\| isa<DeclRefExpr>(IOA))
314	SkippedChecks.set(SanitizerKind::Null, true);
315	}
316	EmitTypeCheck(CodeGenFunction::TCK_MemberCall, CallLoc, This.getPointer(),
317	C.getRecordType(CalleeDecl->getParent()),
318	/Alignment=/CharUnits::Zero(), SkippedChecks);
319
320	// C++ [class.virtual]p12:
321	// Explicit qualification with the scope operator (5.1) suppresses the
322	// virtual call mechanism.
323	//
324	// We also don't emit a virtual call if the base expression has a record type
325	// because then we know what the type is.
326	bool UseVirtualCall = CanUseVirtualCall && !DevirtualizedMethod;
327
328	if (const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(CalleeDecl)) {
329	(0) . __assert_fail ("CE->arg_begin() == CE->arg_end() && \"Destructor shouldn't have explicit parameters\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 330, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(CE->arg_begin() == CE->arg_end() &&
330	(0) . __assert_fail ("CE->arg_begin() == CE->arg_end() && \"Destructor shouldn't have explicit parameters\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 330, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> "Destructor shouldn't have explicit parameters");
331	(0) . __assert_fail ("ReturnValue.isNull() && \"Destructor shouldn't have return value\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 331, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(ReturnValue.isNull() && "Destructor shouldn't have return value");
332	if (UseVirtualCall) {
333	CGM.getCXXABI().EmitVirtualDestructorCall(
334	*this, Dtor, Dtor_Complete, This.getAddress(),
335	cast<CXXMemberCallExpr>(CE));
336	} else {
337	GlobalDecl GD(Dtor, Dtor_Complete);
338	CGCallee Callee;
339	if (getLangOpts().AppleKext && Dtor->isVirtual() && HasQualifier)
340	Callee = BuildAppleKextVirtualCall(Dtor, Qualifier, Ty);
341	else if (!DevirtualizedMethod)
342	Callee =
343	CGCallee::forDirect(CGM.getAddrOfCXXStructor(GD, FInfo, Ty), GD);
344	else {
345	Callee = CGCallee::forDirect(CGM.GetAddrOfFunction(GD, Ty), GD);
346	}
347
348	EmitCXXDestructorCall(GD, Callee, This.getPointer(),
349	/ImplicitParam=/nullptr,
350	/ImplicitParamTy=/QualType(), nullptr);
351	}
352	return RValue::get(nullptr);
353	}
354
355	// FIXME: Uses of 'MD' past this point need to be audited. We may need to use
356	// 'CalleeDecl' instead.
357
358	CGCallee Callee;
359	if (UseVirtualCall) {
360	Callee = CGCallee::forVirtual(CE, MD, This.getAddress(), Ty);
361	} else {
362	if (SanOpts.has(SanitizerKind::CFINVCall) &&
363	MD->getParent()->isDynamicClass()) {
364	llvm::Value *VTable;
365	const CXXRecordDecl *RD;
366	std::tie(VTable, RD) =
367	CGM.getCXXABI().LoadVTablePtr(*this, This.getAddress(),
368	MD->getParent());
369	EmitVTablePtrCheckForCall(RD, VTable, CFITCK_NVCall, CE->getBeginLoc());
370	}
371
372	if (getLangOpts().AppleKext && MD->isVirtual() && HasQualifier)
373	Callee = BuildAppleKextVirtualCall(MD, Qualifier, Ty);
374	else if (!DevirtualizedMethod)
375	Callee =
376	CGCallee::forDirect(CGM.GetAddrOfFunction(MD, Ty), GlobalDecl(MD));
377	else {
378	Callee =
379	CGCallee::forDirect(CGM.GetAddrOfFunction(DevirtualizedMethod, Ty),
380	GlobalDecl(DevirtualizedMethod));
381	}
382	}
383
384	if (MD->isVirtual()) {
385	Address NewThisAddr =
386	CGM.getCXXABI().adjustThisArgumentForVirtualFunctionCall(
387	*this, CalleeDecl, This.getAddress(), UseVirtualCall);
388	This.setAddress(NewThisAddr);
389	}
390
391	return EmitCXXMemberOrOperatorCall(
392	CalleeDecl, Callee, ReturnValue, This.getPointer(),
393	/ImplicitParam=/nullptr, QualType(), CE, RtlArgs);
394	}
395
396	RValue
397	CodeGenFunction::EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E,
398	ReturnValueSlot ReturnValue) {
399	const BinaryOperator *BO =
400	cast<BinaryOperator>(E->getCallee()->IgnoreParens());
401	const Expr *BaseExpr = BO->getLHS();
402	const Expr *MemFnExpr = BO->getRHS();
403
404	const MemberPointerType *MPT =
405	MemFnExpr->getType()->castAs<MemberPointerType>();
406
407	const FunctionProtoType *FPT =
408	MPT->getPointeeType()->castAs<FunctionProtoType>();
409	const CXXRecordDecl *RD =
410	cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl());
411
412	// Emit the 'this' pointer.
413	Address This = Address::invalid();
414	if (BO->getOpcode() == BO_PtrMemI)
415	This = EmitPointerWithAlignment(BaseExpr);
416	else
417	This = EmitLValue(BaseExpr).getAddress();
418
419	EmitTypeCheck(TCK_MemberCall, E->getExprLoc(), This.getPointer(),
420	QualType(MPT->getClass(), 0));
421
422	// Get the member function pointer.
423	llvm::Value *MemFnPtr = EmitScalarExpr(MemFnExpr);
424
425	// Ask the ABI to load the callee. Note that This is modified.
426	llvm::Value *ThisPtrForCall = nullptr;
427	CGCallee Callee =
428	CGM.getCXXABI().EmitLoadOfMemberFunctionPointer(*this, BO, This,
429	ThisPtrForCall, MemFnPtr, MPT);
430
431	CallArgList Args;
432
433	QualType ThisType =
434	getContext().getPointerType(getContext().getTagDeclType(RD));
435
436	// Push the this ptr.
437	Args.add(RValue::get(ThisPtrForCall), ThisType);
438
439	RequiredArgs required = RequiredArgs::forPrototypePlus(FPT, 1);
440
441	// And the rest of the call args
442	EmitCallArgs(Args, FPT, E->arguments());
443	return EmitCall(CGM.getTypes().arrangeCXXMethodCall(Args, FPT, required,
444	/PrefixSize=/0),
445	Callee, ReturnValue, Args, nullptr, E->getExprLoc());
446	}
447
448	RValue
449	CodeGenFunction::EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E,
450	const CXXMethodDecl *MD,
451	ReturnValueSlot ReturnValue) {
452	(0) . __assert_fail ("MD->isInstance() && \"Trying to emit a member call expr on a static method!\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 453, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(MD->isInstance() &&
453	(0) . __assert_fail ("MD->isInstance() && \"Trying to emit a member call expr on a static method!\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 453, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> "Trying to emit a member call expr on a static method!");
454	return EmitCXXMemberOrOperatorMemberCallExpr(
455	E, MD, ReturnValue, /HasQualifier=/false, /Qualifier=/nullptr,
456	/IsArrow=/false, E->getArg(0));
457	}
458
459	RValue CodeGenFunction::EmitCUDAKernelCallExpr(const CUDAKernelCallExpr *E,
460	ReturnValueSlot ReturnValue) {
461	return CGM.getCUDARuntime().EmitCUDAKernelCallExpr(*this, E, ReturnValue);
462	}
463
464	static void EmitNullBaseClassInitialization(CodeGenFunction &CGF,
465	Address DestPtr,
466	const CXXRecordDecl *Base) {
467	if (Base->isEmpty())
468	return;
469
470	DestPtr = CGF.Builder.CreateElementBitCast(DestPtr, CGF.Int8Ty);
471
472	const ASTRecordLayout &Layout = CGF.getContext().getASTRecordLayout(Base);
473	CharUnits NVSize = Layout.getNonVirtualSize();
474
475	// We cannot simply zero-initialize the entire base sub-object if vbptrs are
476	// present, they are initialized by the most derived class before calling the
477	// constructor.
478	SmallVector<std::pair<CharUnits, CharUnits>, 1> Stores;
479	Stores.emplace_back(CharUnits::Zero(), NVSize);
480
481	// Each store is split by the existence of a vbptr.
482	CharUnits VBPtrWidth = CGF.getPointerSize();
483	std::vector<CharUnits> VBPtrOffsets =
484	CGF.CGM.getCXXABI().getVBPtrOffsets(Base);
485	for (CharUnits VBPtrOffset : VBPtrOffsets) {
486	// Stop before we hit any virtual base pointers located in virtual bases.
487	if (VBPtrOffset >= NVSize)
488	break;
489	std::pair<CharUnits, CharUnits> LastStore = Stores.pop_back_val();
490	CharUnits LastStoreOffset = LastStore.first;
491	CharUnits LastStoreSize = LastStore.second;
492
493	CharUnits SplitBeforeOffset = LastStoreOffset;
494	CharUnits SplitBeforeSize = VBPtrOffset - SplitBeforeOffset;
495	(0) . __assert_fail ("!SplitBeforeSize.isNegative() && \"negative store size!\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 495, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(!SplitBeforeSize.isNegative() && "negative store size!");
496	if (!SplitBeforeSize.isZero())
497	Stores.emplace_back(SplitBeforeOffset, SplitBeforeSize);
498
499	CharUnits SplitAfterOffset = VBPtrOffset + VBPtrWidth;
500	CharUnits SplitAfterSize = LastStoreSize - SplitAfterOffset;
501	(0) . __assert_fail ("!SplitAfterSize.isNegative() && \"negative store size!\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 501, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(!SplitAfterSize.isNegative() && "negative store size!");
502	if (!SplitAfterSize.isZero())
503	Stores.emplace_back(SplitAfterOffset, SplitAfterSize);
504	}
505
506	// If the type contains a pointer to data member we can't memset it to zero.
507	// Instead, create a null constant and copy it to the destination.
508	// TODO: there are other patterns besides zero that we can usefully memset,
509	// like -1, which happens to be the pattern used by member-pointers.
510	// TODO: isZeroInitializable can be over-conservative in the case where a
511	// virtual base contains a member pointer.
512	llvm::Constant *NullConstantForBase = CGF.CGM.EmitNullConstantForBase(Base);
513	if (!NullConstantForBase->isNullValue()) {
514	llvm::GlobalVariable *NullVariable = new llvm::GlobalVariable(
515	CGF.CGM.getModule(), NullConstantForBase->getType(),
516	/isConstant=/true, llvm::GlobalVariable::PrivateLinkage,
517	NullConstantForBase, Twine());
518
519	CharUnits Align = std::max(Layout.getNonVirtualAlignment(),
520	DestPtr.getAlignment());
521	NullVariable->setAlignment(Align.getQuantity());
522
523	Address SrcPtr = Address(CGF.EmitCastToVoidPtr(NullVariable), Align);
524
525	// Get and call the appropriate llvm.memcpy overload.
526	for (std::pair<CharUnits, CharUnits> Store : Stores) {
527	CharUnits StoreOffset = Store.first;
528	CharUnits StoreSize = Store.second;
529	llvm::Value *StoreSizeVal = CGF.CGM.getSize(StoreSize);
530	CGF.Builder.CreateMemCpy(
531	CGF.Builder.CreateConstInBoundsByteGEP(DestPtr, StoreOffset),
532	CGF.Builder.CreateConstInBoundsByteGEP(SrcPtr, StoreOffset),
533	StoreSizeVal);
534	}
535
536	// Otherwise, just memset the whole thing to zero. This is legal
537	// because in LLVM, all default initializers (other than the ones we just
538	// handled above) are guaranteed to have a bit pattern of all zeros.
539	} else {
540	for (std::pair<CharUnits, CharUnits> Store : Stores) {
541	CharUnits StoreOffset = Store.first;
542	CharUnits StoreSize = Store.second;
543	llvm::Value *StoreSizeVal = CGF.CGM.getSize(StoreSize);
544	CGF.Builder.CreateMemSet(
545	CGF.Builder.CreateConstInBoundsByteGEP(DestPtr, StoreOffset),
546	CGF.Builder.getInt8(0), StoreSizeVal);
547	}
548	}
549	}
550
551	void
552	CodeGenFunction::EmitCXXConstructExpr(const CXXConstructExpr *E,
553	AggValueSlot Dest) {
554	(0) . __assert_fail ("!Dest.isIgnored() && \"Must have a destination!\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 554, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(!Dest.isIgnored() && "Must have a destination!");
555	const CXXConstructorDecl *CD = E->getConstructor();
556
557	// If we require zero initialization before (or instead of) calling the
558	// constructor, as can be the case with a non-user-provided default
559	// constructor, emit the zero initialization now, unless destination is
560	// already zeroed.
561	if (E->requiresZeroInitialization() && !Dest.isZeroed()) {
562	switch (E->getConstructionKind()) {
563	case CXXConstructExpr::CK_Delegating:
564	case CXXConstructExpr::CK_Complete:
565	EmitNullInitialization(Dest.getAddress(), E->getType());
566	break;
567	case CXXConstructExpr::CK_VirtualBase:
568	case CXXConstructExpr::CK_NonVirtualBase:
569	EmitNullBaseClassInitialization(*this, Dest.getAddress(),
570	CD->getParent());
571	break;
572	}
573	}
574
575	// If this is a call to a trivial default constructor, do nothing.
576	if (CD->isTrivial() && CD->isDefaultConstructor())
577	return;
578
579	// Elide the constructor if we're constructing from a temporary.
580	// The temporary check is required because Sema sets this on NRVO
581	// returns.
582	if (getLangOpts().ElideConstructors && E->isElidable()) {
583	getType(), E->getArg(0)->getType())", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 584, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(getContext().hasSameUnqualifiedType(E->getType(),
584	getType(), E->getArg(0)->getType())", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 584, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> E->getArg(0)->getType()));
585	if (E->getArg(0)->isTemporaryObject(getContext(), CD->getParent())) {
586	EmitAggExpr(E->getArg(0), Dest);
587	return;
588	}
589	}
590
591	if (const ArrayType *arrayType
592	= getContext().getAsArrayType(E->getType())) {
593	EmitCXXAggrConstructorCall(CD, arrayType, Dest.getAddress(), E,
594	Dest.isSanitizerChecked());
595	} else {
596	CXXCtorType Type = Ctor_Complete;
597	bool ForVirtualBase = false;
598	bool Delegating = false;
599
600	switch (E->getConstructionKind()) {
601	case CXXConstructExpr::CK_Delegating:
602	// We should be emitting a constructor; GlobalDecl will assert this
603	Type = CurGD.getCtorType();
604	Delegating = true;
605	break;
606
607	case CXXConstructExpr::CK_Complete:
608	Type = Ctor_Complete;
609	break;
610
611	case CXXConstructExpr::CK_VirtualBase:
612	ForVirtualBase = true;
613	LLVM_FALLTHROUGH;
614
615	case CXXConstructExpr::CK_NonVirtualBase:
616	Type = Ctor_Base;
617	}
618
619	// Call the constructor.
620	EmitCXXConstructorCall(CD, Type, ForVirtualBase, Delegating,
621	Dest.getAddress(), E, Dest.mayOverlap(),
622	Dest.isSanitizerChecked());
623	}
624	}
625
626	void CodeGenFunction::EmitSynthesizedCXXCopyCtor(Address Dest, Address Src,
627	const Expr *Exp) {
628	if (const ExprWithCleanups *E = dyn_cast<ExprWithCleanups>(Exp))
629	Exp = E->getSubExpr();
630	(0) . __assert_fail ("isa(Exp) && \"EmitSynthesizedCXXCopyCtor - unknown copy ctor expr\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 631, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(isa<CXXConstructExpr>(Exp) &&
631	(0) . __assert_fail ("isa(Exp) && \"EmitSynthesizedCXXCopyCtor - unknown copy ctor expr\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 631, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> "EmitSynthesizedCXXCopyCtor - unknown copy ctor expr");
632	const CXXConstructExpr* E = cast<CXXConstructExpr>(Exp);
633	const CXXConstructorDecl *CD = E->getConstructor();
634	RunCleanupsScope Scope(*this);
635
636	// If we require zero initialization before (or instead of) calling the
637	// constructor, as can be the case with a non-user-provided default
638	// constructor, emit the zero initialization now.
639	// FIXME. Do I still need this for a copy ctor synthesis?
640	if (E->requiresZeroInitialization())
641	EmitNullInitialization(Dest, E->getType());
642
643	(0) . __assert_fail ("!getContext().getAsConstantArrayType(E->getType()) && \"EmitSynthesizedCXXCopyCtor - Copied-in Array\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 644, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(!getContext().getAsConstantArrayType(E->getType())
644	(0) . __assert_fail ("!getContext().getAsConstantArrayType(E->getType()) && \"EmitSynthesizedCXXCopyCtor - Copied-in Array\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 644, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> && "EmitSynthesizedCXXCopyCtor - Copied-in Array");
645	EmitSynthesizedCXXCopyCtorCall(CD, Dest, Src, E);
646	}
647
648	static CharUnits CalculateCookiePadding(CodeGenFunction &CGF,
649	const CXXNewExpr *E) {
650	if (!E->isArray())
651	return CharUnits::Zero();
652
653	// No cookie is required if the operator new[] being used is the
654	// reserved placement operator new[].
655	if (E->getOperatorNew()->isReservedGlobalPlacementOperator())
656	return CharUnits::Zero();
657
658	return CGF.CGM.getCXXABI().GetArrayCookieSize(E);
659	}
660
661	static llvm::Value *EmitCXXNewAllocSize(CodeGenFunction &CGF,
662	const CXXNewExpr *e,
663	unsigned minElements,
664	llvm::Value *&numElements,
665	llvm::Value *&sizeWithoutCookie) {
666	QualType type = e->getAllocatedType();
667
668	if (!e->isArray()) {
669	CharUnits typeSize = CGF.getContext().getTypeSizeInChars(type);
670	sizeWithoutCookie
671	= llvm::ConstantInt::get(CGF.SizeTy, typeSize.getQuantity());
672	return sizeWithoutCookie;
673	}
674
675	// The width of size_t.
676	unsigned sizeWidth = CGF.SizeTy->getBitWidth();
677
678	// Figure out the cookie size.
679	llvm::APInt cookieSize(sizeWidth,
680	CalculateCookiePadding(CGF, e).getQuantity());
681
682	// Emit the array size expression.
683	// We multiply the size of all dimensions for NumElements.
684	// e.g for 'int[2][3]', ElemType is 'int' and NumElements is 6.
685	numElements =
686	ConstantEmitter(CGF).tryEmitAbstract(e->getArraySize(), e->getType());
687	if (!numElements)
688	numElements = CGF.EmitScalarExpr(e->getArraySize());
689	(numElements->getType())", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 689, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(isa<llvm::IntegerType>(numElements->getType()));
690
691	// The number of elements can be have an arbitrary integer type;
692	// essentially, we need to multiply it by a constant factor, add a
693	// cookie size, and verify that the result is representable as a
694	// size_t. That's just a gloss, though, and it's wrong in one
695	// important way: if the count is negative, it's an error even if
696	// the cookie size would bring the total size >= 0.
697	bool isSigned
698	= e->getArraySize()->getType()->isSignedIntegerOrEnumerationType();
699	llvm::IntegerType *numElementsType
700	= cast<llvm::IntegerType>(numElements->getType());
701	unsigned numElementsWidth = numElementsType->getBitWidth();
702
703	// Compute the constant factor.
704	llvm::APInt arraySizeMultiplier(sizeWidth, 1);
705	while (const ConstantArrayType *CAT
706	= CGF.getContext().getAsConstantArrayType(type)) {
707	type = CAT->getElementType();
708	arraySizeMultiplier *= CAT->getSize();
709	}
710
711	CharUnits typeSize = CGF.getContext().getTypeSizeInChars(type);
712	llvm::APInt typeSizeMultiplier(sizeWidth, typeSize.getQuantity());
713	typeSizeMultiplier *= arraySizeMultiplier;
714
715	// This will be a size_t.
716	llvm::Value *size;
717
718	// If someone is doing 'new int[42]' there is no need to do a dynamic check.
719	// Don't bloat the -O0 code.
720	if (llvm::ConstantInt *numElementsC =
721	dyn_cast<llvm::ConstantInt>(numElements)) {
722	const llvm::APInt &count = numElementsC->getValue();
723
724	bool hasAnyOverflow = false;
725
726	// If 'count' was a negative number, it's an overflow.
727	if (isSigned && count.isNegative())
728	hasAnyOverflow = true;
729
730	// We want to do all this arithmetic in size_t. If numElements is
731	// wider than that, check whether it's already too big, and if so,
732	// overflow.
733	else if (numElementsWidth > sizeWidth &&
734	numElementsWidth - sizeWidth > count.countLeadingZeros())
735	hasAnyOverflow = true;
736
737	// Okay, compute a count at the right width.
738	llvm::APInt adjustedCount = count.zextOrTrunc(sizeWidth);
739
740	// If there is a brace-initializer, we cannot allocate fewer elements than
741	// there are initializers. If we do, that's treated like an overflow.
742	if (adjustedCount.ult(minElements))
743	hasAnyOverflow = true;
744
745	// Scale numElements by that. This might overflow, but we don't
746	// care because it only overflows if allocationSize does, too, and
747	// if that overflows then we shouldn't use this.
748	numElements = llvm::ConstantInt::get(CGF.SizeTy,
749	adjustedCount * arraySizeMultiplier);
750
751	// Compute the size before cookie, and track whether it overflowed.
752	bool overflow;
753	llvm::APInt allocationSize
754	= adjustedCount.umul_ov(typeSizeMultiplier, overflow);
755	hasAnyOverflow \|= overflow;
756
757	// Add in the cookie, and check whether it's overflowed.
758	if (cookieSize != 0) {
759	// Save the current size without a cookie. This shouldn't be
760	// used if there was overflow.
761	sizeWithoutCookie = llvm::ConstantInt::get(CGF.SizeTy, allocationSize);
762
763	allocationSize = allocationSize.uadd_ov(cookieSize, overflow);
764	hasAnyOverflow \|= overflow;
765	}
766
767	// On overflow, produce a -1 so operator new will fail.
768	if (hasAnyOverflow) {
769	size = llvm::Constant::getAllOnesValue(CGF.SizeTy);
770	} else {
771	size = llvm::ConstantInt::get(CGF.SizeTy, allocationSize);
772	}
773
774	// Otherwise, we might need to use the overflow intrinsics.
775	} else {
776	// There are up to five conditions we need to test for:
777	// 1) if isSigned, we need to check whether numElements is negative;
778	// 2) if numElementsWidth > sizeWidth, we need to check whether
779	// numElements is larger than something representable in size_t;
780	// 3) if minElements > 0, we need to check whether numElements is smaller
781	// than that.
782	// 4) we need to compute
783	// sizeWithoutCookie := numElements * typeSizeMultiplier
784	// and check whether it overflows; and
785	// 5) if we need a cookie, we need to compute
786	// size := sizeWithoutCookie + cookieSize
787	// and check whether it overflows.
788
789	llvm::Value *hasOverflow = nullptr;
790
791	// If numElementsWidth > sizeWidth, then one way or another, we're
792	// going to have to do a comparison for (2), and this happens to
793	// take care of (1), too.
794	if (numElementsWidth > sizeWidth) {
795	llvm::APInt threshold(numElementsWidth, 1);
796	threshold <<= sizeWidth;
797
798	llvm::Value *thresholdV
799	= llvm::ConstantInt::get(numElementsType, threshold);
800
801	hasOverflow = CGF.Builder.CreateICmpUGE(numElements, thresholdV);
802	numElements = CGF.Builder.CreateTrunc(numElements, CGF.SizeTy);
803
804	// Otherwise, if we're signed, we want to sext up to size_t.
805	} else if (isSigned) {
806	if (numElementsWidth < sizeWidth)
807	numElements = CGF.Builder.CreateSExt(numElements, CGF.SizeTy);
808
809	// If there's a non-1 type size multiplier, then we can do the
810	// signedness check at the same time as we do the multiply
811	// because a negative number times anything will cause an
812	// unsigned overflow. Otherwise, we have to do it here. But at least
813	// in this case, we can subsume the >= minElements check.
814	if (typeSizeMultiplier == 1)
815	hasOverflow = CGF.Builder.CreateICmpSLT(numElements,
816	llvm::ConstantInt::get(CGF.SizeTy, minElements));
817
818	// Otherwise, zext up to size_t if necessary.
819	} else if (numElementsWidth < sizeWidth) {
820	numElements = CGF.Builder.CreateZExt(numElements, CGF.SizeTy);
821	}
822
823	getType() == CGF.SizeTy", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 823, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(numElements->getType() == CGF.SizeTy);
824
825	if (minElements) {
826	// Don't allow allocation of fewer elements than we have initializers.
827	if (!hasOverflow) {
828	hasOverflow = CGF.Builder.CreateICmpULT(numElements,
829	llvm::ConstantInt::get(CGF.SizeTy, minElements));
830	} else if (numElementsWidth > sizeWidth) {
831	// The other existing overflow subsumes this check.
832	// We do an unsigned comparison, since any signed value < -1 is
833	// taken care of either above or below.
834	hasOverflow = CGF.Builder.CreateOr(hasOverflow,
835	CGF.Builder.CreateICmpULT(numElements,
836	llvm::ConstantInt::get(CGF.SizeTy, minElements)));
837	}
838	}
839
840	size = numElements;
841
842	// Multiply by the type size if necessary. This multiplier
843	// includes all the factors for nested arrays.
844	//
845	// This step also causes numElements to be scaled up by the
846	// nested-array factor if necessary. Overflow on this computation
847	// can be ignored because the result shouldn't be used if
848	// allocation fails.
849	if (typeSizeMultiplier != 1) {
850	llvm::Function *umul_with_overflow
851	= CGF.CGM.getIntrinsic(llvm::Intrinsic::umul_with_overflow, CGF.SizeTy);
852
853	llvm::Value *tsmV =
854	llvm::ConstantInt::get(CGF.SizeTy, typeSizeMultiplier);
855	llvm::Value *result =
856	CGF.Builder.CreateCall(umul_with_overflow, {size, tsmV});
857
858	llvm::Value *overflowed = CGF.Builder.CreateExtractValue(result, 1);
859	if (hasOverflow)
860	hasOverflow = CGF.Builder.CreateOr(hasOverflow, overflowed);
861	else
862	hasOverflow = overflowed;
863
864	size = CGF.Builder.CreateExtractValue(result, 0);
865
866	// Also scale up numElements by the array size multiplier.
867	if (arraySizeMultiplier != 1) {
868	// If the base element type size is 1, then we can re-use the
869	// multiply we just did.
870	if (typeSize.isOne()) {
871	assert(arraySizeMultiplier == typeSizeMultiplier);
872	numElements = size;
873
874	// Otherwise we need a separate multiply.
875	} else {
876	llvm::Value *asmV =
877	llvm::ConstantInt::get(CGF.SizeTy, arraySizeMultiplier);
878	numElements = CGF.Builder.CreateMul(numElements, asmV);
879	}
880	}
881	} else {
882	// numElements doesn't need to be scaled.
883	assert(arraySizeMultiplier == 1);
884	}
885
886	// Add in the cookie size if necessary.
887	if (cookieSize != 0) {
888	sizeWithoutCookie = size;
889
890	llvm::Function *uadd_with_overflow
891	= CGF.CGM.getIntrinsic(llvm::Intrinsic::uadd_with_overflow, CGF.SizeTy);
892
893	llvm::Value *cookieSizeV = llvm::ConstantInt::get(CGF.SizeTy, cookieSize);
894	llvm::Value *result =
895	CGF.Builder.CreateCall(uadd_with_overflow, {size, cookieSizeV});
896
897	llvm::Value *overflowed = CGF.Builder.CreateExtractValue(result, 1);
898	if (hasOverflow)
899	hasOverflow = CGF.Builder.CreateOr(hasOverflow, overflowed);
900	else
901	hasOverflow = overflowed;
902
903	size = CGF.Builder.CreateExtractValue(result, 0);
904	}
905
906	// If we had any possibility of dynamic overflow, make a select to
907	// overwrite 'size' with an all-ones value, which should cause
908	// operator new to throw.
909	if (hasOverflow)
910	size = CGF.Builder.CreateSelect(hasOverflow,
911	llvm::Constant::getAllOnesValue(CGF.SizeTy),
912	size);
913	}
914
915	if (cookieSize == 0)
916	sizeWithoutCookie = size;
917	else
918	(0) . __assert_fail ("sizeWithoutCookie && \"didn't set sizeWithoutCookie?\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 918, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(sizeWithoutCookie && "didn't set sizeWithoutCookie?");
919
920	return size;
921	}
922
923	static void StoreAnyExprIntoOneUnit(CodeGenFunction &CGF, const Expr *Init,
924	QualType AllocType, Address NewPtr,
925	AggValueSlot::Overlap_t MayOverlap) {
926	// FIXME: Refactor with EmitExprAsInit.
927	switch (CGF.getEvaluationKind(AllocType)) {
928	case TEK_Scalar:
929	CGF.EmitScalarInit(Init, nullptr,
930	CGF.MakeAddrLValue(NewPtr, AllocType), false);
931	return;
932	case TEK_Complex:
933	CGF.EmitComplexExprIntoLValue(Init, CGF.MakeAddrLValue(NewPtr, AllocType),
934	/isInit/ true);
935	return;
936	case TEK_Aggregate: {
937	AggValueSlot Slot
938	= AggValueSlot::forAddr(NewPtr, AllocType.getQualifiers(),
939	AggValueSlot::IsDestructed,
940	AggValueSlot::DoesNotNeedGCBarriers,
941	AggValueSlot::IsNotAliased,
942	MayOverlap, AggValueSlot::IsNotZeroed,
943	AggValueSlot::IsSanitizerChecked);
944	CGF.EmitAggExpr(Init, Slot);
945	return;
946	}
947	}
948	llvm_unreachable("bad evaluation kind");
949	}
950
951	void CodeGenFunction::EmitNewArrayInitializer(
952	const CXXNewExpr E, QualType ElementType, llvm::Type ElementTy,
953	Address BeginPtr, llvm::Value *NumElements,
954	llvm::Value *AllocSizeWithoutCookie) {
955	// If we have a type with trivial initialization and no initializer,
956	// there's nothing to do.
957	if (!E->hasInitializer())
958	return;
959
960	Address CurPtr = BeginPtr;
961
962	unsigned InitListElements = 0;
963
964	const Expr *Init = E->getInitializer();
965	Address EndOfInit = Address::invalid();
966	QualType::DestructionKind DtorKind = ElementType.isDestructedType();
967	EHScopeStack::stable_iterator Cleanup;
968	llvm::Instruction *CleanupDominator = nullptr;
969
970	CharUnits ElementSize = getContext().getTypeSizeInChars(ElementType);
971	CharUnits ElementAlign =
972	BeginPtr.getAlignment().alignmentOfArrayElement(ElementSize);
973
974	// Attempt to perform zero-initialization using memset.
975	auto TryMemsetInitialization = [&]() -> bool {
976	// FIXME: If the type is a pointer-to-data-member under the Itanium ABI,
977	// we can initialize with a memset to -1.
978	if (!CGM.getTypes().isZeroInitializable(ElementType))
979	return false;
980
981	// Optimization: since zero initialization will just set the memory
982	// to all zeroes, generate a single memset to do it in one shot.
983
984	// Subtract out the size of any elements we've already initialized.
985	auto *RemainingSize = AllocSizeWithoutCookie;
986	if (InitListElements) {
987	// We know this can't overflow; we check this when doing the allocation.
988	auto *InitializedSize = llvm::ConstantInt::get(
989	RemainingSize->getType(),
990	getContext().getTypeSizeInChars(ElementType).getQuantity() *
991	InitListElements);
992	RemainingSize = Builder.CreateSub(RemainingSize, InitializedSize);
993	}
994
995	// Create the memset.
996	Builder.CreateMemSet(CurPtr, Builder.getInt8(0), RemainingSize, false);
997	return true;
998	};
999
1000	// If the initializer is an initializer list, first do the explicit elements.
1001	if (const InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
1002	// Initializing from a (braced) string literal is a special case; the init
1003	// list element does not initialize a (single) array element.
1004	if (ILE->isStringLiteralInit()) {
1005	// Initialize the initial portion of length equal to that of the string
1006	// literal. The allocation must be for at least this much; we emitted a
1007	// check for that earlier.
1008	AggValueSlot Slot =
1009	AggValueSlot::forAddr(CurPtr, ElementType.getQualifiers(),
1010	AggValueSlot::IsDestructed,
1011	AggValueSlot::DoesNotNeedGCBarriers,
1012	AggValueSlot::IsNotAliased,
1013	AggValueSlot::DoesNotOverlap,
1014	AggValueSlot::IsNotZeroed,
1015	AggValueSlot::IsSanitizerChecked);
1016	EmitAggExpr(ILE->getInit(0), Slot);
1017
1018	// Move past these elements.
1019	InitListElements =
1020	cast<ConstantArrayType>(ILE->getType()->getAsArrayTypeUnsafe())
1021	->getSize().getZExtValue();
1022	CurPtr =
1023	Address(Builder.CreateInBoundsGEP(CurPtr.getPointer(),
1024	Builder.getSize(InitListElements),
1025	"string.init.end"),
1026	CurPtr.getAlignment().alignmentAtOffset(InitListElements *
1027	ElementSize));
1028
1029	// Zero out the rest, if any remain.
1030	llvm::ConstantInt *ConstNum = dyn_cast<llvm::ConstantInt>(NumElements);
1031	if (!ConstNum \|\| !ConstNum->equalsInt(InitListElements)) {
1032	bool OK = TryMemsetInitialization();
1033	(void)OK;
1034	(0) . __assert_fail ("OK && \"couldn't memset character type?\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1034, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(OK && "couldn't memset character type?");
1035	}
1036	return;
1037	}
1038
1039	InitListElements = ILE->getNumInits();
1040
1041	// If this is a multi-dimensional array new, we will initialize multiple
1042	// elements with each init list element.
1043	QualType AllocType = E->getAllocatedType();
1044	if (const ConstantArrayType *CAT = dyn_cast_or_null<ConstantArrayType>(
1045	AllocType->getAsArrayTypeUnsafe())) {
1046	ElementTy = ConvertTypeForMem(AllocType);
1047	CurPtr = Builder.CreateElementBitCast(CurPtr, ElementTy);
1048	InitListElements *= getContext().getConstantArrayElementCount(CAT);
1049	}
1050
1051	// Enter a partial-destruction Cleanup if necessary.
1052	if (needsEHCleanup(DtorKind)) {
1053	// In principle we could tell the Cleanup where we are more
1054	// directly, but the control flow can get so varied here that it
1055	// would actually be quite complex. Therefore we go through an
1056	// alloca.
1057	EndOfInit = CreateTempAlloca(BeginPtr.getType(), getPointerAlign(),
1058	"array.init.end");
1059	CleanupDominator = Builder.CreateStore(BeginPtr.getPointer(), EndOfInit);
1060	pushIrregularPartialArrayCleanup(BeginPtr.getPointer(), EndOfInit,
1061	ElementType, ElementAlign,
1062	getDestroyer(DtorKind));
1063	Cleanup = EHStack.stable_begin();
1064	}
1065
1066	CharUnits StartAlign = CurPtr.getAlignment();
1067	for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i) {
1068	// Tell the cleanup that it needs to destroy up to this
1069	// element. TODO: some of these stores can be trivially
1070	// observed to be unnecessary.
1071	if (EndOfInit.isValid()) {
1072	auto FinishedPtr =
1073	Builder.CreateBitCast(CurPtr.getPointer(), BeginPtr.getType());
1074	Builder.CreateStore(FinishedPtr, EndOfInit);
1075	}
1076	// FIXME: If the last initializer is an incomplete initializer list for
1077	// an array, and we have an array filler, we can fold together the two
1078	// initialization loops.
1079	StoreAnyExprIntoOneUnit(*this, ILE->getInit(i),
1080	ILE->getInit(i)->getType(), CurPtr,
1081	AggValueSlot::DoesNotOverlap);
1082	CurPtr = Address(Builder.CreateInBoundsGEP(CurPtr.getPointer(),
1083	Builder.getSize(1),
1084	"array.exp.next"),
1085	StartAlign.alignmentAtOffset((i + 1) * ElementSize));
1086	}
1087
1088	// The remaining elements are filled with the array filler expression.
1089	Init = ILE->getArrayFiller();
1090
1091	// Extract the initializer for the individual array elements by pulling
1092	// out the array filler from all the nested initializer lists. This avoids
1093	// generating a nested loop for the initialization.
1094	while (Init && Init->getType()->isConstantArrayType()) {
1095	auto *SubILE = dyn_cast<InitListExpr>(Init);
1096	if (!SubILE)
1097	break;
1098	(0) . __assert_fail ("SubILE->getNumInits() == 0 && \"explicit inits in array filler?\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1098, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(SubILE->getNumInits() == 0 && "explicit inits in array filler?");
1099	Init = SubILE->getArrayFiller();
1100	}
1101
1102	// Switch back to initializing one base element at a time.
1103	CurPtr = Builder.CreateBitCast(CurPtr, BeginPtr.getType());
1104	}
1105
1106	// If all elements have already been initialized, skip any further
1107	// initialization.
1108	llvm::ConstantInt *ConstNum = dyn_cast<llvm::ConstantInt>(NumElements);
1109	if (ConstNum && ConstNum->getZExtValue() <= InitListElements) {
1110	// If there was a Cleanup, deactivate it.
1111	if (CleanupDominator)
1112	DeactivateCleanupBlock(Cleanup, CleanupDominator);
1113	return;
1114	}
1115
1116	(0) . __assert_fail ("Init && \"have trailing elements to initialize but no initializer\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1116, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(Init && "have trailing elements to initialize but no initializer");
1117
1118	// If this is a constructor call, try to optimize it out, and failing that
1119	// emit a single loop to initialize all remaining elements.
1120	if (const CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(Init)) {
1121	CXXConstructorDecl *Ctor = CCE->getConstructor();
1122	if (Ctor->isTrivial()) {
1123	// If new expression did not specify value-initialization, then there
1124	// is no initialization.
1125	if (!CCE->requiresZeroInitialization() \|\| Ctor->getParent()->isEmpty())
1126	return;
1127
1128	if (TryMemsetInitialization())
1129	return;
1130	}
1131
1132	// Store the new Cleanup position for irregular Cleanups.
1133	//
1134	// FIXME: Share this cleanup with the constructor call emission rather than
1135	// having it create a cleanup of its own.
1136	if (EndOfInit.isValid())
1137	Builder.CreateStore(CurPtr.getPointer(), EndOfInit);
1138
1139	// Emit a constructor call loop to initialize the remaining elements.
1140	if (InitListElements)
1141	NumElements = Builder.CreateSub(
1142	NumElements,
1143	llvm::ConstantInt::get(NumElements->getType(), InitListElements));
1144	EmitCXXAggrConstructorCall(Ctor, NumElements, CurPtr, CCE,
1145	/NewPointerIsChecked/true,
1146	CCE->requiresZeroInitialization());
1147	return;
1148	}
1149
1150	// If this is value-initialization, we can usually use memset.
1151	ImplicitValueInitExpr IVIE(ElementType);
1152	if (isa<ImplicitValueInitExpr>(Init)) {
1153	if (TryMemsetInitialization())
1154	return;
1155
1156	// Switch to an ImplicitValueInitExpr for the element type. This handles
1157	// only one case: multidimensional array new of pointers to members. In
1158	// all other cases, we already have an initializer for the array element.
1159	Init = &IVIE;
1160	}
1161
1162	// At this point we should have found an initializer for the individual
1163	// elements of the array.
1164	(0) . __assert_fail ("getContext().hasSameUnqualifiedType(ElementType, Init->getType()) && \"got wrong type of element to initialize\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1165, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(getContext().hasSameUnqualifiedType(ElementType, Init->getType()) &&
1165	(0) . __assert_fail ("getContext().hasSameUnqualifiedType(ElementType, Init->getType()) && \"got wrong type of element to initialize\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1165, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> "got wrong type of element to initialize");
1166
1167	// If we have an empty initializer list, we can usually use memset.
1168	if (auto *ILE = dyn_cast<InitListExpr>(Init))
1169	if (ILE->getNumInits() == 0 && TryMemsetInitialization())
1170	return;
1171
1172	// If we have a struct whose every field is value-initialized, we can
1173	// usually use memset.
1174	if (auto *ILE = dyn_cast<InitListExpr>(Init)) {
1175	if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) {
1176	if (RType->getDecl()->isStruct()) {
1177	unsigned NumElements = 0;
1178	if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RType->getDecl()))
1179	NumElements = CXXRD->getNumBases();
1180	for (auto *Field : RType->getDecl()->fields())
1181	if (!Field->isUnnamedBitfield())
1182	++NumElements;
1183	// FIXME: Recurse into nested InitListExprs.
1184	if (ILE->getNumInits() == NumElements)
1185	for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i)
1186	if (!isa<ImplicitValueInitExpr>(ILE->getInit(i)))
1187	--NumElements;
1188	if (ILE->getNumInits() == NumElements && TryMemsetInitialization())
1189	return;
1190	}
1191	}
1192	}
1193
1194	// Create the loop blocks.
1195	llvm::BasicBlock *EntryBB = Builder.GetInsertBlock();
1196	llvm::BasicBlock *LoopBB = createBasicBlock("new.loop");
1197	llvm::BasicBlock *ContBB = createBasicBlock("new.loop.end");
1198
1199	// Find the end of the array, hoisted out of the loop.
1200	llvm::Value *EndPtr =
1201	Builder.CreateInBoundsGEP(BeginPtr.getPointer(), NumElements, "array.end");
1202
1203	// If the number of elements isn't constant, we have to now check if there is
1204	// anything left to initialize.
1205	if (!ConstNum) {
1206	llvm::Value *IsEmpty =
1207	Builder.CreateICmpEQ(CurPtr.getPointer(), EndPtr, "array.isempty");
1208	Builder.CreateCondBr(IsEmpty, ContBB, LoopBB);
1209	}
1210
1211	// Enter the loop.
1212	EmitBlock(LoopBB);
1213
1214	// Set up the current-element phi.
1215	llvm::PHINode *CurPtrPhi =
1216	Builder.CreatePHI(CurPtr.getType(), 2, "array.cur");
1217	CurPtrPhi->addIncoming(CurPtr.getPointer(), EntryBB);
1218
1219	CurPtr = Address(CurPtrPhi, ElementAlign);
1220
1221	// Store the new Cleanup position for irregular Cleanups.
1222	if (EndOfInit.isValid())
1223	Builder.CreateStore(CurPtr.getPointer(), EndOfInit);
1224
1225	// Enter a partial-destruction Cleanup if necessary.
1226	if (!CleanupDominator && needsEHCleanup(DtorKind)) {
1227	pushRegularPartialArrayCleanup(BeginPtr.getPointer(), CurPtr.getPointer(),
1228	ElementType, ElementAlign,
1229	getDestroyer(DtorKind));
1230	Cleanup = EHStack.stable_begin();
1231	CleanupDominator = Builder.CreateUnreachable();
1232	}
1233
1234	// Emit the initializer into this element.
1235	StoreAnyExprIntoOneUnit(*this, Init, Init->getType(), CurPtr,
1236	AggValueSlot::DoesNotOverlap);
1237
1238	// Leave the Cleanup if we entered one.
1239	if (CleanupDominator) {
1240	DeactivateCleanupBlock(Cleanup, CleanupDominator);
1241	CleanupDominator->eraseFromParent();
1242	}
1243
1244	// Advance to the next element by adjusting the pointer type as necessary.
1245	llvm::Value *NextPtr =
1246	Builder.CreateConstInBoundsGEP1_32(ElementTy, CurPtr.getPointer(), 1,
1247	"array.next");
1248
1249	// Check whether we've gotten to the end of the array and, if so,
1250	// exit the loop.
1251	llvm::Value *IsEnd = Builder.CreateICmpEQ(NextPtr, EndPtr, "array.atend");
1252	Builder.CreateCondBr(IsEnd, ContBB, LoopBB);
1253	CurPtrPhi->addIncoming(NextPtr, Builder.GetInsertBlock());
1254
1255	EmitBlock(ContBB);
1256	}
1257
1258	static void EmitNewInitializer(CodeGenFunction &CGF, const CXXNewExpr *E,
1259	QualType ElementType, llvm::Type *ElementTy,
1260	Address NewPtr, llvm::Value *NumElements,
1261	llvm::Value *AllocSizeWithoutCookie) {
1262	ApplyDebugLocation DL(CGF, E);
1263	if (E->isArray())
1264	CGF.EmitNewArrayInitializer(E, ElementType, ElementTy, NewPtr, NumElements,
1265	AllocSizeWithoutCookie);
1266	else if (const Expr *Init = E->getInitializer())
1267	StoreAnyExprIntoOneUnit(CGF, Init, E->getAllocatedType(), NewPtr,
1268	AggValueSlot::DoesNotOverlap);
1269	}
1270
1271	/// Emit a call to an operator new or operator delete function, as implicitly
1272	/// created by new-expressions and delete-expressions.
1273	static RValue EmitNewDeleteCall(CodeGenFunction &CGF,
1274	const FunctionDecl *CalleeDecl,
1275	const FunctionProtoType *CalleeType,
1276	const CallArgList &Args) {
1277	llvm::CallBase *CallOrInvoke;
1278	llvm::Constant *CalleePtr = CGF.CGM.GetAddrOfFunction(CalleeDecl);
1279	CGCallee Callee = CGCallee::forDirect(CalleePtr, GlobalDecl(CalleeDecl));
1280	RValue RV =
1281	CGF.EmitCall(CGF.CGM.getTypes().arrangeFreeFunctionCall(
1282	Args, CalleeType, /chainCall=/false),
1283	Callee, ReturnValueSlot(), Args, &CallOrInvoke);
1284
1285	/// C++1y [expr.new]p10:
1286	/// [In a new-expression,] an implementation is allowed to omit a call
1287	/// to a replaceable global allocation function.
1288	///
1289	/// We model such elidable calls with the 'builtin' attribute.
1290	llvm::Function *Fn = dyn_cast<llvm::Function>(CalleePtr);
1291	if (CalleeDecl->isReplaceableGlobalAllocationFunction() &&
1292	Fn && Fn->hasFnAttribute(llvm::Attribute::NoBuiltin)) {
1293	CallOrInvoke->addAttribute(llvm::AttributeList::FunctionIndex,
1294	llvm::Attribute::Builtin);
1295	}
1296
1297	return RV;
1298	}
1299
1300	RValue CodeGenFunction::EmitBuiltinNewDeleteCall(const FunctionProtoType *Type,
1301	const CallExpr *TheCall,
1302	bool IsDelete) {
1303	CallArgList Args;
1304	EmitCallArgs(Args, Type->getParamTypes(), TheCall->arguments());
1305	// Find the allocation or deallocation function that we're calling.
1306	ASTContext &Ctx = getContext();
1307	DeclarationName Name = Ctx.DeclarationNames
1308	.getCXXOperatorName(IsDelete ? OO_Delete : OO_New);
1309
1310	for (auto *Decl : Ctx.getTranslationUnitDecl()->lookup(Name))
1311	if (auto *FD = dyn_cast<FunctionDecl>(Decl))
1312	if (Ctx.hasSameType(FD->getType(), QualType(Type, 0)))
1313	return EmitNewDeleteCall(*this, FD, Type, Args);
1314	llvm_unreachable("predeclared global operator new/delete is missing");
1315	}
1316
1317	namespace {
1318	/// The parameters to pass to a usual operator delete.
1319	struct UsualDeleteParams {
1320	bool DestroyingDelete = false;
1321	bool Size = false;
1322	bool Alignment = false;
1323	};
1324	}
1325
1326	static UsualDeleteParams getUsualDeleteParams(const FunctionDecl *FD) {
1327	UsualDeleteParams Params;
1328
1329	const FunctionProtoType *FPT = FD->getType()->castAs<FunctionProtoType>();
1330	auto AI = FPT->param_type_begin(), AE = FPT->param_type_end();
1331
1332	// The first argument is always a void*.
1333	++AI;
1334
1335	// The next parameter may be a std::destroying_delete_t.
1336	if (FD->isDestroyingOperatorDelete()) {
1337	Params.DestroyingDelete = true;
1338	assert(AI != AE);
1339	++AI;
1340	}
1341
1342	// Figure out what other parameters we should be implicitly passing.
1343	if (AI != AE && (*AI)->isIntegerType()) {
1344	Params.Size = true;
1345	++AI;
1346	}
1347
1348	if (AI != AE && (*AI)->isAlignValT()) {
1349	Params.Alignment = true;
1350	++AI;
1351	}
1352
1353	(0) . __assert_fail ("AI == AE && \"unexpected usual deallocation function parameter\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1353, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(AI == AE && "unexpected usual deallocation function parameter");
1354	return Params;
1355	}
1356
1357	namespace {
1358	/// A cleanup to call the given 'operator delete' function upon abnormal
1359	/// exit from a new expression. Templated on a traits type that deals with
1360	/// ensuring that the arguments dominate the cleanup if necessary.
1361	template<typename Traits>
1362	class CallDeleteDuringNew final : public EHScopeStack::Cleanup {
1363	/// Type used to hold llvm::Value*s.
1364	typedef typename Traits::ValueTy ValueTy;
1365	/// Type used to hold RValues.
1366	typedef typename Traits::RValueTy RValueTy;
1367	struct PlacementArg {
1368	RValueTy ArgValue;
1369	QualType ArgType;
1370	};
1371
1372	unsigned NumPlacementArgs : 31;
1373	unsigned PassAlignmentToPlacementDelete : 1;
1374	const FunctionDecl *OperatorDelete;
1375	ValueTy Ptr;
1376	ValueTy AllocSize;
1377	CharUnits AllocAlign;
1378
1379	PlacementArg *getPlacementArgs() {
1380	return reinterpret_cast<PlacementArg *>(this + 1);
1381	}
1382
1383	public:
1384	static size_t getExtraSize(size_t NumPlacementArgs) {
1385	return NumPlacementArgs * sizeof(PlacementArg);
1386	}
1387
1388	CallDeleteDuringNew(size_t NumPlacementArgs,
1389	const FunctionDecl *OperatorDelete, ValueTy Ptr,
1390	ValueTy AllocSize, bool PassAlignmentToPlacementDelete,
1391	CharUnits AllocAlign)
1392	: NumPlacementArgs(NumPlacementArgs),
1393	PassAlignmentToPlacementDelete(PassAlignmentToPlacementDelete),
1394	OperatorDelete(OperatorDelete), Ptr(Ptr), AllocSize(AllocSize),
1395	AllocAlign(AllocAlign) {}
1396
1397	void setPlacementArg(unsigned I, RValueTy Arg, QualType Type) {
1398	(0) . __assert_fail ("I < NumPlacementArgs && \"index out of range\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1398, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(I < NumPlacementArgs && "index out of range");
1399	getPlacementArgs()[I] = {Arg, Type};
1400	}
1401
1402	void Emit(CodeGenFunction &CGF, Flags flags) override {
1403	const FunctionProtoType *FPT =
1404	OperatorDelete->getType()->getAs<FunctionProtoType>();
1405	CallArgList DeleteArgs;
1406
1407	// The first argument is always a void* (or C* for a destroying operator
1408	// delete for class type C).
1409	DeleteArgs.add(Traits::get(CGF, Ptr), FPT->getParamType(0));
1410
1411	// Figure out what other parameters we should be implicitly passing.
1412	UsualDeleteParams Params;
1413	if (NumPlacementArgs) {
1414	// A placement deallocation function is implicitly passed an alignment
1415	// if the placement allocation function was, but is never passed a size.
1416	Params.Alignment = PassAlignmentToPlacementDelete;
1417	} else {
1418	// For a non-placement new-expression, 'operator delete' can take a
1419	// size and/or an alignment if it has the right parameters.
1420	Params = getUsualDeleteParams(OperatorDelete);
1421	}
1422
1423	(0) . __assert_fail ("!Params.DestroyingDelete && \"should not call destroying delete in a new-expression\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1424, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(!Params.DestroyingDelete &&
1424	(0) . __assert_fail ("!Params.DestroyingDelete && \"should not call destroying delete in a new-expression\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1424, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> "should not call destroying delete in a new-expression");
1425
1426	// The second argument can be a std::size_t (for non-placement delete).
1427	if (Params.Size)
1428	DeleteArgs.add(Traits::get(CGF, AllocSize),
1429	CGF.getContext().getSizeType());
1430
1431	// The next (second or third) argument can be a std::align_val_t, which
1432	// is an enum whose underlying type is std::size_t.
1433	// FIXME: Use the right type as the parameter type. Note that in a call
1434	// to operator delete(size_t, ...), we may not have it available.
1435	if (Params.Alignment)
1436	DeleteArgs.add(RValue::get(llvm::ConstantInt::get(
1437	CGF.SizeTy, AllocAlign.getQuantity())),
1438	CGF.getContext().getSizeType());
1439
1440	// Pass the rest of the arguments, which must match exactly.
1441	for (unsigned I = 0; I != NumPlacementArgs; ++I) {
1442	auto Arg = getPlacementArgs()[I];
1443	DeleteArgs.add(Traits::get(CGF, Arg.ArgValue), Arg.ArgType);
1444	}
1445
1446	// Call 'operator delete'.
1447	EmitNewDeleteCall(CGF, OperatorDelete, FPT, DeleteArgs);
1448	}
1449	};
1450	}
1451
1452	/// Enter a cleanup to call 'operator delete' if the initializer in a
1453	/// new-expression throws.
1454	static void EnterNewDeleteCleanup(CodeGenFunction &CGF,
1455	const CXXNewExpr *E,
1456	Address NewPtr,
1457	llvm::Value *AllocSize,
1458	CharUnits AllocAlign,
1459	const CallArgList &NewArgs) {
1460	unsigned NumNonPlacementArgs = E->passAlignment() ? 2 : 1;
1461
1462	// If we're not inside a conditional branch, then the cleanup will
1463	// dominate and we can do the easier (and more efficient) thing.
1464	if (!CGF.isInConditionalBranch()) {
1465	struct DirectCleanupTraits {
1466	typedef llvm::Value *ValueTy;
1467	typedef RValue RValueTy;
1468	static RValue get(CodeGenFunction &, ValueTy V) { return RValue::get(V); }
1469	static RValue get(CodeGenFunction &, RValueTy V) { return V; }
1470	};
1471
1472	typedef CallDeleteDuringNew<DirectCleanupTraits> DirectCleanup;
1473
1474	DirectCleanup *Cleanup = CGF.EHStack
1475	.pushCleanupWithExtra<DirectCleanup>(EHCleanup,
1476	E->getNumPlacementArgs(),
1477	E->getOperatorDelete(),
1478	NewPtr.getPointer(),
1479	AllocSize,
1480	E->passAlignment(),
1481	AllocAlign);
1482	for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) {
1483	auto &Arg = NewArgs[I + NumNonPlacementArgs];
1484	Cleanup->setPlacementArg(I, Arg.getRValue(CGF), Arg.Ty);
1485	}
1486
1487	return;
1488	}
1489
1490	// Otherwise, we need to save all this stuff.
1491	DominatingValue<RValue>::saved_type SavedNewPtr =
1492	DominatingValue<RValue>::save(CGF, RValue::get(NewPtr.getPointer()));
1493	DominatingValue<RValue>::saved_type SavedAllocSize =
1494	DominatingValue<RValue>::save(CGF, RValue::get(AllocSize));
1495
1496	struct ConditionalCleanupTraits {
1497	typedef DominatingValue<RValue>::saved_type ValueTy;
1498	typedef DominatingValue<RValue>::saved_type RValueTy;
1499	static RValue get(CodeGenFunction &CGF, ValueTy V) {
1500	return V.restore(CGF);
1501	}
1502	};
1503	typedef CallDeleteDuringNew<ConditionalCleanupTraits> ConditionalCleanup;
1504
1505	ConditionalCleanup *Cleanup = CGF.EHStack
1506	.pushCleanupWithExtra<ConditionalCleanup>(EHCleanup,
1507	E->getNumPlacementArgs(),
1508	E->getOperatorDelete(),
1509	SavedNewPtr,
1510	SavedAllocSize,
1511	E->passAlignment(),
1512	AllocAlign);
1513	for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) {
1514	auto &Arg = NewArgs[I + NumNonPlacementArgs];
1515	Cleanup->setPlacementArg(
1516	I, DominatingValue<RValue>::save(CGF, Arg.getRValue(CGF)), Arg.Ty);
1517	}
1518
1519	CGF.initFullExprCleanup();
1520	}
1521
1522	llvm::Value CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr E) {
1523	// The element type being allocated.
1524	QualType allocType = getContext().getBaseElementType(E->getAllocatedType());
1525
1526	// 1. Build a call to the allocation function.
1527	FunctionDecl *allocator = E->getOperatorNew();
1528
1529	// If there is a brace-initializer, cannot allocate fewer elements than inits.
1530	unsigned minElements = 0;
1531	if (E->isArray() && E->hasInitializer()) {
1532	const InitListExpr *ILE = dyn_cast<InitListExpr>(E->getInitializer());
1533	if (ILE && ILE->isStringLiteralInit())
1534	minElements =
1535	cast<ConstantArrayType>(ILE->getType()->getAsArrayTypeUnsafe())
1536	->getSize().getZExtValue();
1537	else if (ILE)
1538	minElements = ILE->getNumInits();
1539	}
1540
1541	llvm::Value *numElements = nullptr;
1542	llvm::Value *allocSizeWithoutCookie = nullptr;
1543	llvm::Value *allocSize =
1544	EmitCXXNewAllocSize(*this, E, minElements, numElements,
1545	allocSizeWithoutCookie);
1546	CharUnits allocAlign = getContext().getTypeAlignInChars(allocType);
1547
1548	// Emit the allocation call. If the allocator is a global placement
1549	// operator, just "inline" it directly.
1550	Address allocation = Address::invalid();
1551	CallArgList allocatorArgs;
1552	if (allocator->isReservedGlobalPlacementOperator()) {
1553	getNumPlacementArgs() == 1", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1553, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(E->getNumPlacementArgs() == 1);
1554	const Expr arg = E->placement_arguments().begin();
1555
1556	LValueBaseInfo BaseInfo;
1557	allocation = EmitPointerWithAlignment(arg, &BaseInfo);
1558
1559	// The pointer expression will, in many cases, be an opaque void*.
1560	// In these cases, discard the computed alignment and use the
1561	// formal alignment of the allocated type.
1562	if (BaseInfo.getAlignmentSource() != AlignmentSource::Decl)
1563	allocation = Address(allocation.getPointer(), allocAlign);
1564
1565	// Set up allocatorArgs for the call to operator delete if it's not
1566	// the reserved global operator.
1567	if (E->getOperatorDelete() &&
1568	!E->getOperatorDelete()->isReservedGlobalPlacementOperator()) {
1569	allocatorArgs.add(RValue::get(allocSize), getContext().getSizeType());
1570	allocatorArgs.add(RValue::get(allocation.getPointer()), arg->getType());
1571	}
1572
1573	} else {
1574	const FunctionProtoType *allocatorType =
1575	allocator->getType()->castAs<FunctionProtoType>();
1576	unsigned ParamsToSkip = 0;
1577
1578	// The allocation size is the first argument.
1579	QualType sizeType = getContext().getSizeType();
1580	allocatorArgs.add(RValue::get(allocSize), sizeType);
1581	++ParamsToSkip;
1582
1583	if (allocSize != allocSizeWithoutCookie) {
1584	CharUnits cookieAlign = getSizeAlign(); // FIXME: Ask the ABI.
1585	allocAlign = std::max(allocAlign, cookieAlign);
1586	}
1587
1588	// The allocation alignment may be passed as the second argument.
1589	if (E->passAlignment()) {
1590	QualType AlignValT = sizeType;
1591	if (allocatorType->getNumParams() > 1) {
1592	AlignValT = allocatorType->getParamType(1);
1593	(0) . __assert_fail ("getContext().hasSameUnqualifiedType( AlignValT->castAs()->getDecl()->getIntegerType(), sizeType) && \"wrong type for alignment parameter\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1596, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(getContext().hasSameUnqualifiedType(
1594	(0) . __assert_fail ("getContext().hasSameUnqualifiedType( AlignValT->castAs()->getDecl()->getIntegerType(), sizeType) && \"wrong type for alignment parameter\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1596, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> AlignValT->castAs<EnumType>()->getDecl()->getIntegerType(),
1595	(0) . __assert_fail ("getContext().hasSameUnqualifiedType( AlignValT->castAs()->getDecl()->getIntegerType(), sizeType) && \"wrong type for alignment parameter\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1596, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> sizeType) &&
1596	(0) . __assert_fail ("getContext().hasSameUnqualifiedType( AlignValT->castAs()->getDecl()->getIntegerType(), sizeType) && \"wrong type for alignment parameter\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1596, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> "wrong type for alignment parameter");
1597	++ParamsToSkip;
1598	} else {
1599	// Corner case, passing alignment to 'operator new(size_t, ...)'.
1600	(0) . __assert_fail ("allocator->isVariadic() && \"can't pass alignment to allocator\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1600, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(allocator->isVariadic() && "can't pass alignment to allocator");
1601	}
1602	allocatorArgs.add(
1603	RValue::get(llvm::ConstantInt::get(SizeTy, allocAlign.getQuantity())),
1604	AlignValT);
1605	}
1606
1607	// FIXME: Why do we not pass a CalleeDecl here?
1608	EmitCallArgs(allocatorArgs, allocatorType, E->placement_arguments(),
1609	/AC/AbstractCallee(), /ParamsToSkip/ParamsToSkip);
1610
1611	RValue RV =
1612	EmitNewDeleteCall(*this, allocator, allocatorType, allocatorArgs);
1613
1614	// If this was a call to a global replaceable allocation function that does
1615	// not take an alignment argument, the allocator is known to produce
1616	// storage that's suitably aligned for any object that fits, up to a known
1617	// threshold. Otherwise assume it's suitably aligned for the allocated type.
1618	CharUnits allocationAlign = allocAlign;
1619	if (!E->passAlignment() &&
1620	allocator->isReplaceableGlobalAllocationFunction()) {
1621	unsigned AllocatorAlign = llvm::PowerOf2Floor(std::min<uint64_t>(
1622	Target.getNewAlign(), getContext().getTypeSize(allocType)));
1623	allocationAlign = std::max(
1624	allocationAlign, getContext().toCharUnitsFromBits(AllocatorAlign));
1625	}
1626
1627	allocation = Address(RV.getScalarVal(), allocationAlign);
1628	}
1629
1630	// Emit a null check on the allocation result if the allocation
1631	// function is allowed to return null (because it has a non-throwing
1632	// exception spec or is the reserved placement new) and we have an
1633	// interesting initializer will be running sanitizers on the initialization.
1634	bool nullCheck = E->shouldNullCheckAllocation() &&
1635	(!allocType.isPODType(getContext()) \|\| E->hasInitializer() \|\|
1636	sanitizePerformTypeCheck());
1637
1638	llvm::BasicBlock *nullCheckBB = nullptr;
1639	llvm::BasicBlock *contBB = nullptr;
1640
1641	// The null-check means that the initializer is conditionally
1642	// evaluated.
1643	ConditionalEvaluation conditional(*this);
1644
1645	if (nullCheck) {
1646	conditional.begin(*this);
1647
1648	nullCheckBB = Builder.GetInsertBlock();
1649	llvm::BasicBlock *notNullBB = createBasicBlock("new.notnull");
1650	contBB = createBasicBlock("new.cont");
1651
1652	llvm::Value *isNull =
1653	Builder.CreateIsNull(allocation.getPointer(), "new.isnull");
1654	Builder.CreateCondBr(isNull, contBB, notNullBB);
1655	EmitBlock(notNullBB);
1656	}
1657
1658	// If there's an operator delete, enter a cleanup to call it if an
1659	// exception is thrown.
1660	EHScopeStack::stable_iterator operatorDeleteCleanup;
1661	llvm::Instruction *cleanupDominator = nullptr;
1662	if (E->getOperatorDelete() &&
1663	!E->getOperatorDelete()->isReservedGlobalPlacementOperator()) {
1664	EnterNewDeleteCleanup(*this, E, allocation, allocSize, allocAlign,
1665	allocatorArgs);
1666	operatorDeleteCleanup = EHStack.stable_begin();
1667	cleanupDominator = Builder.CreateUnreachable();
1668	}
1669
1670	assert((allocSize == allocSizeWithoutCookie) ==
1671	CalculateCookiePadding(*this, E).isZero());
1672	if (allocSize != allocSizeWithoutCookie) {
1673	isArray()", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1673, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(E->isArray());
1674	allocation = CGM.getCXXABI().InitializeArrayCookie(*this, allocation,
1675	numElements,
1676	E, allocType);
1677	}
1678
1679	llvm::Type *elementTy = ConvertTypeForMem(allocType);
1680	Address result = Builder.CreateElementBitCast(allocation, elementTy);
1681
1682	// Passing pointer through launder.invariant.group to avoid propagation of
1683	// vptrs information which may be included in previous type.
1684	// To not break LTO with different optimizations levels, we do it regardless
1685	// of optimization level.
1686	if (CGM.getCodeGenOpts().StrictVTablePointers &&
1687	allocator->isReservedGlobalPlacementOperator())
1688	result = Address(Builder.CreateLaunderInvariantGroup(result.getPointer()),
1689	result.getAlignment());
1690
1691	// Emit sanitizer checks for pointer value now, so that in the case of an
1692	// array it was checked only once and not at each constructor call. We may
1693	// have already checked that the pointer is non-null.
1694	// FIXME: If we have an array cookie and a potentially-throwing allocator,
1695	// we'll null check the wrong pointer here.
1696	SanitizerSet SkippedChecks;
1697	SkippedChecks.set(SanitizerKind::Null, nullCheck);
1698	EmitTypeCheck(CodeGenFunction::TCK_ConstructorCall,
1699	E->getAllocatedTypeSourceInfo()->getTypeLoc().getBeginLoc(),
1700	result.getPointer(), allocType, result.getAlignment(),
1701	SkippedChecks, numElements);
1702
1703	EmitNewInitializer(*this, E, allocType, elementTy, result, numElements,
1704	allocSizeWithoutCookie);
1705	if (E->isArray()) {
1706	// NewPtr is a pointer to the base element type. If we're
1707	// allocating an array of arrays, we'll need to cast back to the
1708	// array pointer type.
1709	llvm::Type *resultType = ConvertTypeForMem(E->getType());
1710	if (result.getType() != resultType)
1711	result = Builder.CreateBitCast(result, resultType);
1712	}
1713
1714	// Deactivate the 'operator delete' cleanup if we finished
1715	// initialization.
1716	if (operatorDeleteCleanup.isValid()) {
1717	DeactivateCleanupBlock(operatorDeleteCleanup, cleanupDominator);
1718	cleanupDominator->eraseFromParent();
1719	}
1720
1721	llvm::Value *resultPtr = result.getPointer();
1722	if (nullCheck) {
1723	conditional.end(*this);
1724
1725	llvm::BasicBlock *notNullBB = Builder.GetInsertBlock();
1726	EmitBlock(contBB);
1727
1728	llvm::PHINode *PHI = Builder.CreatePHI(resultPtr->getType(), 2);
1729	PHI->addIncoming(resultPtr, notNullBB);
1730	PHI->addIncoming(llvm::Constant::getNullValue(resultPtr->getType()),
1731	nullCheckBB);
1732
1733	resultPtr = PHI;
1734	}
1735
1736	return resultPtr;
1737	}
1738
1739	void CodeGenFunction::EmitDeleteCall(const FunctionDecl *DeleteFD,
1740	llvm::Value *Ptr, QualType DeleteTy,
1741	llvm::Value *NumElements,
1742	CharUnits CookieSize) {
1743	getOverloadedOperator() == OO_Array_Delete", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1744, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert((!NumElements && CookieSize.isZero()) \|\|
1744	getOverloadedOperator() == OO_Array_Delete", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1744, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> DeleteFD->getOverloadedOperator() == OO_Array_Delete);
1745
1746	const FunctionProtoType *DeleteFTy =
1747	DeleteFD->getType()->getAs<FunctionProtoType>();
1748
1749	CallArgList DeleteArgs;
1750
1751	auto Params = getUsualDeleteParams(DeleteFD);
1752	auto ParamTypeIt = DeleteFTy->param_type_begin();
1753
1754	// Pass the pointer itself.
1755	QualType ArgTy = *ParamTypeIt++;
1756	llvm::Value *DeletePtr = Builder.CreateBitCast(Ptr, ConvertType(ArgTy));
1757	DeleteArgs.add(RValue::get(DeletePtr), ArgTy);
1758
1759	// Pass the std::destroying_delete tag if present.
1760	if (Params.DestroyingDelete) {
1761	QualType DDTag = *ParamTypeIt++;
1762	// Just pass an 'undef'. We expect the tag type to be an empty struct.
1763	auto *V = llvm::UndefValue::get(getTypes().ConvertType(DDTag));
1764	DeleteArgs.add(RValue::get(V), DDTag);
1765	}
1766
1767	// Pass the size if the delete function has a size_t parameter.
1768	if (Params.Size) {
1769	QualType SizeType = *ParamTypeIt++;
1770	CharUnits DeleteTypeSize = getContext().getTypeSizeInChars(DeleteTy);
1771	llvm::Value *Size = llvm::ConstantInt::get(ConvertType(SizeType),
1772	DeleteTypeSize.getQuantity());
1773
1774	// For array new, multiply by the number of elements.
1775	if (NumElements)
1776	Size = Builder.CreateMul(Size, NumElements);
1777
1778	// If there is a cookie, add the cookie size.
1779	if (!CookieSize.isZero())
1780	Size = Builder.CreateAdd(
1781	Size, llvm::ConstantInt::get(SizeTy, CookieSize.getQuantity()));
1782
1783	DeleteArgs.add(RValue::get(Size), SizeType);
1784	}
1785
1786	// Pass the alignment if the delete function has an align_val_t parameter.
1787	if (Params.Alignment) {
1788	QualType AlignValType = *ParamTypeIt++;
1789	CharUnits DeleteTypeAlign = getContext().toCharUnitsFromBits(
1790	getContext().getTypeAlignIfKnown(DeleteTy));
1791	llvm::Value *Align = llvm::ConstantInt::get(ConvertType(AlignValType),
1792	DeleteTypeAlign.getQuantity());
1793	DeleteArgs.add(RValue::get(Align), AlignValType);
1794	}
1795
1796	(0) . __assert_fail ("ParamTypeIt == DeleteFTy->param_type_end() && \"unknown parameter to usual delete function\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1797, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(ParamTypeIt == DeleteFTy->param_type_end() &&
1797	(0) . __assert_fail ("ParamTypeIt == DeleteFTy->param_type_end() && \"unknown parameter to usual delete function\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1797, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> "unknown parameter to usual delete function");
1798
1799	// Emit the call to delete.
1800	EmitNewDeleteCall(*this, DeleteFD, DeleteFTy, DeleteArgs);
1801	}
1802
1803	namespace {
1804	/// Calls the given 'operator delete' on a single object.
1805	struct CallObjectDelete final : EHScopeStack::Cleanup {
1806	llvm::Value *Ptr;
1807	const FunctionDecl *OperatorDelete;
1808	QualType ElementType;
1809
1810	CallObjectDelete(llvm::Value *Ptr,
1811	const FunctionDecl *OperatorDelete,
1812	QualType ElementType)
1813	: Ptr(Ptr), OperatorDelete(OperatorDelete), ElementType(ElementType) {}
1814
1815	void Emit(CodeGenFunction &CGF, Flags flags) override {
1816	CGF.EmitDeleteCall(OperatorDelete, Ptr, ElementType);
1817	}
1818	};
1819	}
1820
1821	void
1822	CodeGenFunction::pushCallObjectDeleteCleanup(const FunctionDecl *OperatorDelete,
1823	llvm::Value *CompletePtr,
1824	QualType ElementType) {
1825	EHStack.pushCleanup<CallObjectDelete>(NormalAndEHCleanup, CompletePtr,
1826	OperatorDelete, ElementType);
1827	}
1828
1829	/// Emit the code for deleting a single object with a destroying operator
1830	/// delete. If the element type has a non-virtual destructor, Ptr has already
1831	/// been converted to the type of the parameter of 'operator delete'. Otherwise
1832	/// Ptr points to an object of the static type.
1833	static void EmitDestroyingObjectDelete(CodeGenFunction &CGF,
1834	const CXXDeleteExpr *DE, Address Ptr,
1835	QualType ElementType) {
1836	auto *Dtor = ElementType->getAsCXXRecordDecl()->getDestructor();
1837	if (Dtor && Dtor->isVirtual())
1838	CGF.CGM.getCXXABI().emitVirtualObjectDelete(CGF, DE, Ptr, ElementType,
1839	Dtor);
1840	else
1841	CGF.EmitDeleteCall(DE->getOperatorDelete(), Ptr.getPointer(), ElementType);
1842	}
1843
1844	/// Emit the code for deleting a single object.
1845	static void EmitObjectDelete(CodeGenFunction &CGF,
1846	const CXXDeleteExpr *DE,
1847	Address Ptr,
1848	QualType ElementType) {
1849	// C++11 [expr.delete]p3:
1850	// If the static type of the object to be deleted is different from its
1851	// dynamic type, the static type shall be a base class of the dynamic type
1852	// of the object to be deleted and the static type shall have a virtual
1853	// destructor or the behavior is undefined.
1854	CGF.EmitTypeCheck(CodeGenFunction::TCK_MemberCall,
1855	DE->getExprLoc(), Ptr.getPointer(),
1856	ElementType);
1857
1858	const FunctionDecl *OperatorDelete = DE->getOperatorDelete();
1859	isDestroyingOperatorDelete()", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1859, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(!OperatorDelete->isDestroyingOperatorDelete());
1860
1861	// Find the destructor for the type, if applicable. If the
1862	// destructor is virtual, we'll just emit the vcall and return.
1863	const CXXDestructorDecl *Dtor = nullptr;
1864	if (const RecordType *RT = ElementType->getAs<RecordType>()) {
1865	CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1866	if (RD->hasDefinition() && !RD->hasTrivialDestructor()) {
1867	Dtor = RD->getDestructor();
1868
1869	if (Dtor->isVirtual()) {
1870	CGF.CGM.getCXXABI().emitVirtualObjectDelete(CGF, DE, Ptr, ElementType,
1871	Dtor);
1872	return;
1873	}
1874	}
1875	}
1876
1877	// Make sure that we call delete even if the dtor throws.
1878	// This doesn't have to a conditional cleanup because we're going
1879	// to pop it off in a second.
1880	CGF.EHStack.pushCleanup<CallObjectDelete>(NormalAndEHCleanup,
1881	Ptr.getPointer(),
1882	OperatorDelete, ElementType);
1883
1884	if (Dtor)
1885	CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete,
1886	/ForVirtualBase=/false,
1887	/Delegating=/false,
1888	Ptr);
1889	else if (auto Lifetime = ElementType.getObjCLifetime()) {
1890	switch (Lifetime) {
1891	case Qualifiers::OCL_None:
1892	case Qualifiers::OCL_ExplicitNone:
1893	case Qualifiers::OCL_Autoreleasing:
1894	break;
1895
1896	case Qualifiers::OCL_Strong:
1897	CGF.EmitARCDestroyStrong(Ptr, ARCPreciseLifetime);
1898	break;
1899
1900	case Qualifiers::OCL_Weak:
1901	CGF.EmitARCDestroyWeak(Ptr);
1902	break;
1903	}
1904	}
1905
1906	CGF.PopCleanupBlock();
1907	}
1908
1909	namespace {
1910	/// Calls the given 'operator delete' on an array of objects.
1911	struct CallArrayDelete final : EHScopeStack::Cleanup {
1912	llvm::Value *Ptr;
1913	const FunctionDecl *OperatorDelete;
1914	llvm::Value *NumElements;
1915	QualType ElementType;
1916	CharUnits CookieSize;
1917
1918	CallArrayDelete(llvm::Value *Ptr,
1919	const FunctionDecl *OperatorDelete,
1920	llvm::Value *NumElements,
1921	QualType ElementType,
1922	CharUnits CookieSize)
1923	: Ptr(Ptr), OperatorDelete(OperatorDelete), NumElements(NumElements),
1924	ElementType(ElementType), CookieSize(CookieSize) {}
1925
1926	void Emit(CodeGenFunction &CGF, Flags flags) override {
1927	CGF.EmitDeleteCall(OperatorDelete, Ptr, ElementType, NumElements,
1928	CookieSize);
1929	}
1930	};
1931	}
1932
1933	/// Emit the code for deleting an array of objects.
1934	static void EmitArrayDelete(CodeGenFunction &CGF,
1935	const CXXDeleteExpr *E,
1936	Address deletedPtr,
1937	QualType elementType) {
1938	llvm::Value *numElements = nullptr;
1939	llvm::Value *allocatedPtr = nullptr;
1940	CharUnits cookieSize;
1941	CGF.CGM.getCXXABI().ReadArrayCookie(CGF, deletedPtr, E, elementType,
1942	numElements, allocatedPtr, cookieSize);
1943
1944	(0) . __assert_fail ("allocatedPtr && \"ReadArrayCookie didn't set allocated pointer\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1944, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(allocatedPtr && "ReadArrayCookie didn't set allocated pointer");
1945
1946	// Make sure that we call delete even if one of the dtors throws.
1947	const FunctionDecl *operatorDelete = E->getOperatorDelete();
1948	CGF.EHStack.pushCleanup<CallArrayDelete>(NormalAndEHCleanup,
1949	allocatedPtr, operatorDelete,
1950	numElements, elementType,
1951	cookieSize);
1952
1953	// Destroy the elements.
1954	if (QualType::DestructionKind dtorKind = elementType.isDestructedType()) {
1955	(0) . __assert_fail ("numElements && \"no element count for a type with a destructor!\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 1955, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(numElements && "no element count for a type with a destructor!");
1956
1957	CharUnits elementSize = CGF.getContext().getTypeSizeInChars(elementType);
1958	CharUnits elementAlign =
1959	deletedPtr.getAlignment().alignmentOfArrayElement(elementSize);
1960
1961	llvm::Value *arrayBegin = deletedPtr.getPointer();
1962	llvm::Value *arrayEnd =
1963	CGF.Builder.CreateInBoundsGEP(arrayBegin, numElements, "delete.end");
1964
1965	// Note that it is legal to allocate a zero-length array, and we
1966	// can never fold the check away because the length should always
1967	// come from a cookie.
1968	CGF.emitArrayDestroy(arrayBegin, arrayEnd, elementType, elementAlign,
1969	CGF.getDestroyer(dtorKind),
1970	/checkZeroLength/ true,
1971	CGF.needsEHCleanup(dtorKind));
1972	}
1973
1974	// Pop the cleanup block.
1975	CGF.PopCleanupBlock();
1976	}
1977
1978	void CodeGenFunction::EmitCXXDeleteExpr(const CXXDeleteExpr *E) {
1979	const Expr *Arg = E->getArgument();
1980	Address Ptr = EmitPointerWithAlignment(Arg);
1981
1982	// Null check the pointer.
1983	llvm::BasicBlock *DeleteNotNull = createBasicBlock("delete.notnull");
1984	llvm::BasicBlock *DeleteEnd = createBasicBlock("delete.end");
1985
1986	llvm::Value *IsNull = Builder.CreateIsNull(Ptr.getPointer(), "isnull");
1987
1988	Builder.CreateCondBr(IsNull, DeleteEnd, DeleteNotNull);
1989	EmitBlock(DeleteNotNull);
1990
1991	QualType DeleteTy = E->getDestroyedType();
1992
1993	// A destroying operator delete overrides the entire operation of the
1994	// delete expression.
1995	if (E->getOperatorDelete()->isDestroyingOperatorDelete()) {
1996	EmitDestroyingObjectDelete(*this, E, Ptr, DeleteTy);
1997	EmitBlock(DeleteEnd);
1998	return;
1999	}
2000
2001	// We might be deleting a pointer to array. If so, GEP down to the
2002	// first non-array element.
2003	// (this assumes that A()[3][7] is converted to [3 x [7 x %A]])
2004	if (DeleteTy->isConstantArrayType()) {
2005	llvm::Value *Zero = Builder.getInt32(0);
2006	SmallVector<llvm::Value*,8> GEP;
2007
2008	GEP.push_back(Zero); // point at the outermost array
2009
2010	// For each layer of array type we're pointing at:
2011	while (const ConstantArrayType *Arr
2012	= getContext().getAsConstantArrayType(DeleteTy)) {
2013	// 1. Unpeel the array type.
2014	DeleteTy = Arr->getElementType();
2015
2016	// 2. GEP to the first element of the array.
2017	GEP.push_back(Zero);
2018	}
2019
2020	Ptr = Address(Builder.CreateInBoundsGEP(Ptr.getPointer(), GEP, "del.first"),
2021	Ptr.getAlignment());
2022	}
2023
2024	assert(ConvertTypeForMem(DeleteTy) == Ptr.getElementType());
2025
2026	if (E->isArrayForm()) {
2027	EmitArrayDelete(*this, E, Ptr, DeleteTy);
2028	} else {
2029	EmitObjectDelete(*this, E, Ptr, DeleteTy);
2030	}
2031
2032	EmitBlock(DeleteEnd);
2033	}
2034
2035	static bool isGLValueFromPointerDeref(const Expr *E) {
2036	E = E->IgnoreParens();
2037
2038	if (const auto *CE = dyn_cast<CastExpr>(E)) {
2039	if (!CE->getSubExpr()->isGLValue())
2040	return false;
2041	return isGLValueFromPointerDeref(CE->getSubExpr());
2042	}
2043
2044	if (const auto *OVE = dyn_cast<OpaqueValueExpr>(E))
2045	return isGLValueFromPointerDeref(OVE->getSourceExpr());
2046
2047	if (const auto *BO = dyn_cast<BinaryOperator>(E))
2048	if (BO->getOpcode() == BO_Comma)
2049	return isGLValueFromPointerDeref(BO->getRHS());
2050
2051	if (const auto *ACO = dyn_cast<AbstractConditionalOperator>(E))
2052	return isGLValueFromPointerDeref(ACO->getTrueExpr()) \|\|
2053	isGLValueFromPointerDeref(ACO->getFalseExpr());
2054
2055	// C++11 [expr.sub]p1:
2056	// The expression E1[E2] is identical (by definition) to *((E1)+(E2))
2057	if (isa<ArraySubscriptExpr>(E))
2058	return true;
2059
2060	if (const auto *UO = dyn_cast<UnaryOperator>(E))
2061	if (UO->getOpcode() == UO_Deref)
2062	return true;
2063
2064	return false;
2065	}
2066
2067	static llvm::Value EmitTypeidFromVTable(CodeGenFunction &CGF, const Expr E,
2068	llvm::Type *StdTypeInfoPtrTy) {
2069	// Get the vtable pointer.
2070	Address ThisPtr = CGF.EmitLValue(E).getAddress();
2071
2072	QualType SrcRecordTy = E->getType();
2073
2074	// C++ [class.cdtor]p4:
2075	// If the operand of typeid refers to the object under construction or
2076	// destruction and the static type of the operand is neither the constructor
2077	// or destructor’s class nor one of its bases, the behavior is undefined.
2078	CGF.EmitTypeCheck(CodeGenFunction::TCK_DynamicOperation, E->getExprLoc(),
2079	ThisPtr.getPointer(), SrcRecordTy);
2080
2081	// C++ [expr.typeid]p2:
2082	// If the glvalue expression is obtained by applying the unary * operator to
2083	// a pointer and the pointer is a null pointer value, the typeid expression
2084	// throws the std::bad_typeid exception.
2085	//
2086	// However, this paragraph's intent is not clear. We choose a very generous
2087	// interpretation which implores us to consider comma operators, conditional
2088	// operators, parentheses and other such constructs.
2089	if (CGF.CGM.getCXXABI().shouldTypeidBeNullChecked(
2090	isGLValueFromPointerDeref(E), SrcRecordTy)) {
2091	llvm::BasicBlock *BadTypeidBlock =
2092	CGF.createBasicBlock("typeid.bad_typeid");
2093	llvm::BasicBlock *EndBlock = CGF.createBasicBlock("typeid.end");
2094
2095	llvm::Value *IsNull = CGF.Builder.CreateIsNull(ThisPtr.getPointer());
2096	CGF.Builder.CreateCondBr(IsNull, BadTypeidBlock, EndBlock);
2097
2098	CGF.EmitBlock(BadTypeidBlock);
2099	CGF.CGM.getCXXABI().EmitBadTypeidCall(CGF);
2100	CGF.EmitBlock(EndBlock);
2101	}
2102
2103	return CGF.CGM.getCXXABI().EmitTypeid(CGF, SrcRecordTy, ThisPtr,
2104	StdTypeInfoPtrTy);
2105	}
2106
2107	llvm::Value CodeGenFunction::EmitCXXTypeidExpr(const CXXTypeidExpr E) {
2108	llvm::Type *StdTypeInfoPtrTy =
2109	ConvertType(E->getType())->getPointerTo();
2110
2111	if (E->isTypeOperand()) {
2112	llvm::Constant *TypeInfo =
2113	CGM.GetAddrOfRTTIDescriptor(E->getTypeOperand(getContext()));
2114	return Builder.CreateBitCast(TypeInfo, StdTypeInfoPtrTy);
2115	}
2116
2117	// C++ [expr.typeid]p2:
2118	// When typeid is applied to a glvalue expression whose type is a
2119	// polymorphic class type, the result refers to a std::type_info object
2120	// representing the type of the most derived object (that is, the dynamic
2121	// type) to which the glvalue refers.
2122	if (E->isPotentiallyEvaluated())
2123	return EmitTypeidFromVTable(*this, E->getExprOperand(),
2124	StdTypeInfoPtrTy);
2125
2126	QualType OperandTy = E->getExprOperand()->getType();
2127	return Builder.CreateBitCast(CGM.GetAddrOfRTTIDescriptor(OperandTy),
2128	StdTypeInfoPtrTy);
2129	}
2130
2131	static llvm::Value *EmitDynamicCastToNull(CodeGenFunction &CGF,
2132	QualType DestTy) {
2133	llvm::Type *DestLTy = CGF.ConvertType(DestTy);
2134	if (DestTy->isPointerType())
2135	return llvm::Constant::getNullValue(DestLTy);
2136
2137	/// C++ [expr.dynamic.cast]p9:
2138	/// A failed cast to reference type throws std::bad_cast
2139	if (!CGF.CGM.getCXXABI().EmitBadCastCall(CGF))
2140	return nullptr;
2141
2142	CGF.EmitBlock(CGF.createBasicBlock("dynamic_cast.end"));
2143	return llvm::UndefValue::get(DestLTy);
2144	}
2145
2146	llvm::Value *CodeGenFunction::EmitDynamicCast(Address ThisAddr,
2147	const CXXDynamicCastExpr *DCE) {
2148	CGM.EmitExplicitCastExprType(DCE, this);
2149	QualType DestTy = DCE->getTypeAsWritten();
2150
2151	QualType SrcTy = DCE->getSubExpr()->getType();
2152
2153	// C++ [expr.dynamic.cast]p7:
2154	// If T is "pointer to cv void," then the result is a pointer to the most
2155	// derived object pointed to by v.
2156	const PointerType *DestPTy = DestTy->getAs<PointerType>();
2157
2158	bool isDynamicCastToVoid;
2159	QualType SrcRecordTy;
2160	QualType DestRecordTy;
2161	if (DestPTy) {
2162	isDynamicCastToVoid = DestPTy->getPointeeType()->isVoidType();
2163	SrcRecordTy = SrcTy->castAs<PointerType>()->getPointeeType();
2164	DestRecordTy = DestPTy->getPointeeType();
2165	} else {
2166	isDynamicCastToVoid = false;
2167	SrcRecordTy = SrcTy;
2168	DestRecordTy = DestTy->castAs<ReferenceType>()->getPointeeType();
2169	}
2170
2171	// C++ [class.cdtor]p5:
2172	// If the operand of the dynamic_cast refers to the object under
2173	// construction or destruction and the static type of the operand is not a
2174	// pointer to or object of the constructor or destructor’s own class or one
2175	// of its bases, the dynamic_cast results in undefined behavior.
2176	EmitTypeCheck(TCK_DynamicOperation, DCE->getExprLoc(), ThisAddr.getPointer(),
2177	SrcRecordTy);
2178
2179	if (DCE->isAlwaysNull())
2180	if (llvm::Value T = EmitDynamicCastToNull(this, DestTy))
2181	return T;
2182
2183	(0) . __assert_fail ("SrcRecordTy->isRecordType() && \"source type must be a record type!\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 2183, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(SrcRecordTy->isRecordType() && "source type must be a record type!");
2184
2185	// C++ [expr.dynamic.cast]p4:
2186	// If the value of v is a null pointer value in the pointer case, the result
2187	// is the null pointer value of type T.
2188	bool ShouldNullCheckSrcValue =
2189	CGM.getCXXABI().shouldDynamicCastCallBeNullChecked(SrcTy->isPointerType(),
2190	SrcRecordTy);
2191
2192	llvm::BasicBlock *CastNull = nullptr;
2193	llvm::BasicBlock *CastNotNull = nullptr;
2194	llvm::BasicBlock *CastEnd = createBasicBlock("dynamic_cast.end");
2195
2196	if (ShouldNullCheckSrcValue) {
2197	CastNull = createBasicBlock("dynamic_cast.null");
2198	CastNotNull = createBasicBlock("dynamic_cast.notnull");
2199
2200	llvm::Value *IsNull = Builder.CreateIsNull(ThisAddr.getPointer());
2201	Builder.CreateCondBr(IsNull, CastNull, CastNotNull);
2202	EmitBlock(CastNotNull);
2203	}
2204
2205	llvm::Value *Value;
2206	if (isDynamicCastToVoid) {
2207	Value = CGM.getCXXABI().EmitDynamicCastToVoid(*this, ThisAddr, SrcRecordTy,
2208	DestTy);
2209	} else {
2210	(0) . __assert_fail ("DestRecordTy->isRecordType() && \"destination type must be a record type!\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 2211, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(DestRecordTy->isRecordType() &&
2211	(0) . __assert_fail ("DestRecordTy->isRecordType() && \"destination type must be a record type!\"", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGExprCXX.cpp", 2211, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true"> "destination type must be a record type!");
2212	Value = CGM.getCXXABI().EmitDynamicCastCall(*this, ThisAddr, SrcRecordTy,
2213	DestTy, DestRecordTy, CastEnd);
2214	CastNotNull = Builder.GetInsertBlock();
2215	}
2216
2217	if (ShouldNullCheckSrcValue) {
2218	EmitBranch(CastEnd);
2219
2220	EmitBlock(CastNull);
2221	EmitBranch(CastEnd);
2222	}
2223
2224	EmitBlock(CastEnd);
2225
2226	if (ShouldNullCheckSrcValue) {
2227	llvm::PHINode *PHI = Builder.CreatePHI(Value->getType(), 2);
2228	PHI->addIncoming(Value, CastNotNull);
2229	PHI->addIncoming(llvm::Constant::getNullValue(Value->getType()), CastNull);
2230
2231	Value = PHI;
2232	}
2233
2234	return Value;
2235	}
2236