blob: dfbd411e885d8c63e3ca5763bf61ab30cfa45168 [file] [log] [blame]
Anders Carlsson5ec2e7c2009-12-10 00:16:00 +00001//===--- CGDeclCXX.cpp - Emit LLVM Code for C++ declarations --------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This contains code dealing with code generation of C++ declarations
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenFunction.h"
Fariborz Jahanianec805122011-01-13 20:00:54 +000015#include "CGObjCRuntime.h"
John McCall4c40d982010-08-31 07:33:07 +000016#include "CGCXXABI.h"
Chandler Carruth06057ce2010-06-15 23:19:56 +000017#include "clang/Frontend/CodeGenOptions.h"
Douglas Gregor86a3a032010-05-16 01:24:12 +000018#include "llvm/Intrinsics.h"
19
Anders Carlsson5ec2e7c2009-12-10 00:16:00 +000020using namespace clang;
21using namespace CodeGen;
22
Anders Carlssonfcbfdc12009-12-10 00:57:45 +000023static void EmitDeclInit(CodeGenFunction &CGF, const VarDecl &D,
24 llvm::Constant *DeclPtr) {
25 assert(D.hasGlobalStorage() && "VarDecl must have global storage!");
26 assert(!D.getType()->isReferenceType() &&
27 "Should not call EmitDeclInit on a reference!");
28
Anders Carlssonfcbfdc12009-12-10 00:57:45 +000029 ASTContext &Context = CGF.getContext();
Anders Carlsson5ec2e7c2009-12-10 00:16:00 +000030
Eli Friedman6da2c712011-12-03 04:14:32 +000031 CharUnits alignment = Context.getDeclAlign(&D);
John McCalla07398e2011-06-16 04:16:24 +000032 QualType type = D.getType();
33 LValue lv = CGF.MakeAddrLValue(DeclPtr, type, alignment);
34
35 const Expr *Init = D.getInit();
36 if (!CGF.hasAggregateLLVMType(type)) {
Fariborz Jahanianec805122011-01-13 20:00:54 +000037 CodeGenModule &CGM = CGF.CGM;
John McCalla07398e2011-06-16 04:16:24 +000038 if (lv.isObjCStrong())
John McCallf85e1932011-06-15 23:02:42 +000039 CGM.getObjCRuntime().EmitObjCGlobalAssign(CGF, CGF.EmitScalarExpr(Init),
40 DeclPtr, D.isThreadSpecified());
John McCalla07398e2011-06-16 04:16:24 +000041 else if (lv.isObjCWeak())
42 CGM.getObjCRuntime().EmitObjCWeakAssign(CGF, CGF.EmitScalarExpr(Init),
43 DeclPtr);
Fariborz Jahanianec805122011-01-13 20:00:54 +000044 else
John McCalla07398e2011-06-16 04:16:24 +000045 CGF.EmitScalarInit(Init, &D, lv, false);
46 } else if (type->isAnyComplexType()) {
47 CGF.EmitComplexExprIntoAddr(Init, DeclPtr, lv.isVolatile());
Anders Carlsson5ec2e7c2009-12-10 00:16:00 +000048 } else {
John McCall57cd1b82012-03-28 23:30:44 +000049 CGF.EmitAggExpr(Init, AggValueSlot::forLValue(lv,
50 AggValueSlot::IsDestructed,
51 AggValueSlot::DoesNotNeedGCBarriers,
52 AggValueSlot::IsNotAliased,
53 AggValueSlot::IsCompleteObject));
Anders Carlsson5ec2e7c2009-12-10 00:16:00 +000054 }
55}
56
John McCall5cd91b52010-09-08 01:44:27 +000057/// Emit code to cause the destruction of the given variable with
58/// static storage duration.
Douglas Gregorcc6a44b2010-05-05 15:38:32 +000059static void EmitDeclDestroy(CodeGenFunction &CGF, const VarDecl &D,
John McCalla91f6662011-07-13 03:01:35 +000060 llvm::Constant *addr) {
Douglas Gregorcc6a44b2010-05-05 15:38:32 +000061 CodeGenModule &CGM = CGF.CGM;
John McCalla91f6662011-07-13 03:01:35 +000062
63 // FIXME: __attribute__((cleanup)) ?
Douglas Gregorcc6a44b2010-05-05 15:38:32 +000064
John McCalla91f6662011-07-13 03:01:35 +000065 QualType type = D.getType();
66 QualType::DestructionKind dtorKind = type.isDestructedType();
67
68 switch (dtorKind) {
69 case QualType::DK_none:
Douglas Gregorcc6a44b2010-05-05 15:38:32 +000070 return;
John McCalla91f6662011-07-13 03:01:35 +000071
72 case QualType::DK_cxx_destructor:
73 break;
74
75 case QualType::DK_objc_strong_lifetime:
76 case QualType::DK_objc_weak_lifetime:
77 // We don't care about releasing objects during process teardown.
Douglas Gregorcc6a44b2010-05-05 15:38:32 +000078 return;
John McCalla91f6662011-07-13 03:01:35 +000079 }
80
81 llvm::Constant *function;
82 llvm::Constant *argument;
83
84 // Special-case non-array C++ destructors, where there's a function
85 // with the right signature that we can just call.
86 const CXXRecordDecl *record = 0;
87 if (dtorKind == QualType::DK_cxx_destructor &&
88 (record = type->getAsCXXRecordDecl())) {
89 assert(!record->hasTrivialDestructor());
90 CXXDestructorDecl *dtor = record->getDestructor();
91
92 function = CGM.GetAddrOfCXXDestructor(dtor, Dtor_Complete);
93 argument = addr;
94
95 // Otherwise, the standard logic requires a helper function.
96 } else {
97 function = CodeGenFunction(CGM).generateDestroyHelper(addr, type,
98 CGF.getDestroyer(dtorKind),
99 CGF.needsEHCleanup(dtorKind));
100 argument = llvm::Constant::getNullValue(CGF.Int8PtrTy);
101 }
102
103 CGF.EmitCXXGlobalDtorRegistration(function, argument);
Douglas Gregorcc6a44b2010-05-05 15:38:32 +0000104}
105
Richard Smithabb94322012-02-17 07:31:37 +0000106/// Emit code to cause the variable at the given address to be considered as
107/// constant from this point onwards.
Nick Lewyckyef784462012-02-21 00:26:58 +0000108static void EmitDeclInvariant(CodeGenFunction &CGF, const VarDecl &D,
109 llvm::Constant *Addr) {
Richard Smith00a8c3f2012-02-17 20:12:52 +0000110 // Don't emit the intrinsic if we're not optimizing.
111 if (!CGF.CGM.getCodeGenOpts().OptimizationLevel)
112 return;
113
Richard Smithabb94322012-02-17 07:31:37 +0000114 // Grab the llvm.invariant.start intrinsic.
115 llvm::Intrinsic::ID InvStartID = llvm::Intrinsic::invariant_start;
116 llvm::Constant *InvariantStart = CGF.CGM.getIntrinsic(InvStartID);
117
Nick Lewyckyef784462012-02-21 00:26:58 +0000118 // Emit a call with the size in bytes of the object.
119 CharUnits WidthChars = CGF.getContext().getTypeSizeInChars(D.getType());
120 uint64_t Width = WidthChars.getQuantity();
121 llvm::Value *Args[2] = { llvm::ConstantInt::getSigned(CGF.Int64Ty, Width),
Richard Smithabb94322012-02-17 07:31:37 +0000122 llvm::ConstantExpr::getBitCast(Addr, CGF.Int8PtrTy)};
123 CGF.Builder.CreateCall(InvariantStart, Args);
124}
125
Anders Carlssonfcbfdc12009-12-10 00:57:45 +0000126void CodeGenFunction::EmitCXXGlobalVarDeclInit(const VarDecl &D,
Richard Smith7ca48502012-02-13 22:16:19 +0000127 llvm::Constant *DeclPtr,
128 bool PerformInit) {
Anders Carlssonfcbfdc12009-12-10 00:57:45 +0000129
130 const Expr *Init = D.getInit();
131 QualType T = D.getType();
132
133 if (!T->isReferenceType()) {
Richard Smith7ca48502012-02-13 22:16:19 +0000134 if (PerformInit)
135 EmitDeclInit(*this, D, DeclPtr);
Richard Smithabb94322012-02-17 07:31:37 +0000136 if (CGM.isTypeConstant(D.getType(), true))
Nick Lewyckyef784462012-02-21 00:26:58 +0000137 EmitDeclInvariant(*this, D, DeclPtr);
Richard Smithabb94322012-02-17 07:31:37 +0000138 else
139 EmitDeclDestroy(*this, D, DeclPtr);
Anders Carlssonfcbfdc12009-12-10 00:57:45 +0000140 return;
141 }
Anders Carlsson045a6d82010-06-27 17:52:15 +0000142
Richard Smith7ca48502012-02-13 22:16:19 +0000143 assert(PerformInit && "cannot have constant initializer which needs "
144 "destruction for reference");
Daniel Dunbar91a16fa2010-08-21 02:24:36 +0000145 unsigned Alignment = getContext().getDeclAlign(&D).getQuantity();
Anders Carlsson045a6d82010-06-27 17:52:15 +0000146 RValue RV = EmitReferenceBindingToExpr(Init, &D);
Daniel Dunbar91a16fa2010-08-21 02:24:36 +0000147 EmitStoreOfScalar(RV.getScalarVal(), DeclPtr, false, Alignment, T);
Anders Carlssonfcbfdc12009-12-10 00:57:45 +0000148}
Anders Carlssoneb4072e2009-12-10 00:30:05 +0000149
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000150void
151CodeGenFunction::EmitCXXGlobalDtorRegistration(llvm::Constant *DtorFn,
152 llvm::Constant *DeclPtr) {
153 // Generate a global destructor entry if not using __cxa_atexit.
154 if (!CGM.getCodeGenOpts().CXAAtExit) {
155 CGM.AddCXXDtorEntry(DtorFn, DeclPtr);
156 return;
157 }
158
Anders Carlssoneb4072e2009-12-10 00:30:05 +0000159 // Get the destructor function type
Chris Lattner8b418682012-02-07 00:39:47 +0000160 llvm::Type *DtorFnTy = llvm::FunctionType::get(VoidTy, Int8PtrTy, false);
Anders Carlssoneb4072e2009-12-10 00:30:05 +0000161 DtorFnTy = llvm::PointerType::getUnqual(DtorFnTy);
162
Chris Lattner9cbe4f02011-07-09 17:41:47 +0000163 llvm::Type *Params[] = { DtorFnTy, Int8PtrTy, Int8PtrTy };
Anders Carlssoneb4072e2009-12-10 00:30:05 +0000164
165 // Get the __cxa_atexit function type
166 // extern "C" int __cxa_atexit ( void (*f)(void *), void *p, void *d );
Chris Lattner2acc6e32011-07-18 04:24:23 +0000167 llvm::FunctionType *AtExitFnTy =
Anders Carlssoneb4072e2009-12-10 00:30:05 +0000168 llvm::FunctionType::get(ConvertType(getContext().IntTy), Params, false);
169
170 llvm::Constant *AtExitFn = CGM.CreateRuntimeFunction(AtExitFnTy,
171 "__cxa_atexit");
Anders Carlssonbd4a0732011-03-20 20:52:32 +0000172 if (llvm::Function *Fn = dyn_cast<llvm::Function>(AtExitFn))
173 Fn->setDoesNotThrow();
Anders Carlssoneb4072e2009-12-10 00:30:05 +0000174
175 llvm::Constant *Handle = CGM.CreateRuntimeVariable(Int8PtrTy,
176 "__dso_handle");
177 llvm::Value *Args[3] = { llvm::ConstantExpr::getBitCast(DtorFn, DtorFnTy),
178 llvm::ConstantExpr::getBitCast(DeclPtr, Int8PtrTy),
179 llvm::ConstantExpr::getBitCast(Handle, Int8PtrTy) };
Jay Foad4c7d9f12011-07-15 08:37:34 +0000180 Builder.CreateCall(AtExitFn, Args);
Anders Carlssoneb4072e2009-12-10 00:30:05 +0000181}
182
John McCall3030eb82010-11-06 09:44:32 +0000183void CodeGenFunction::EmitCXXGuardedInit(const VarDecl &D,
Richard Smith7ca48502012-02-13 22:16:19 +0000184 llvm::GlobalVariable *DeclPtr,
185 bool PerformInit) {
John McCall32096692011-03-18 02:56:14 +0000186 // If we've been asked to forbid guard variables, emit an error now.
187 // This diagnostic is hard-coded for Darwin's use case; we can find
188 // better phrasing if someone else needs it.
189 if (CGM.getCodeGenOpts().ForbidGuardVariables)
190 CGM.Error(D.getLocation(),
191 "this initialization requires a guard variable, which "
192 "the kernel does not support");
193
Richard Smith7ca48502012-02-13 22:16:19 +0000194 CGM.getCXXABI().EmitGuardedInit(*this, D, DeclPtr, PerformInit);
John McCall5cd91b52010-09-08 01:44:27 +0000195}
196
Anders Carlsson9dc046e2010-06-08 22:40:05 +0000197static llvm::Function *
198CreateGlobalInitOrDestructFunction(CodeGenModule &CGM,
Chris Lattner2acc6e32011-07-18 04:24:23 +0000199 llvm::FunctionType *FTy,
NAKAMURA Takumia0786c92012-03-28 16:24:29 +0000200 const Twine &Name) {
Anders Carlsson9dc046e2010-06-08 22:40:05 +0000201 llvm::Function *Fn =
202 llvm::Function::Create(FTy, llvm::GlobalValue::InternalLinkage,
203 Name, &CGM.getModule());
David Blaikie4e4d0842012-03-11 07:00:24 +0000204 if (!CGM.getContext().getLangOpts().AppleKext) {
Fariborz Jahaniand6c9a0f2011-02-15 18:54:46 +0000205 // Set the section if needed.
206 if (const char *Section =
Douglas Gregorbcfd1f52011-09-02 00:18:52 +0000207 CGM.getContext().getTargetInfo().getStaticInitSectionSpecifier())
Fariborz Jahaniand6c9a0f2011-02-15 18:54:46 +0000208 Fn->setSection(Section);
209 }
Anders Carlsson18af3682010-06-08 22:47:50 +0000210
David Blaikie4e4d0842012-03-11 07:00:24 +0000211 if (!CGM.getLangOpts().Exceptions)
John McCall044cc542010-07-06 04:38:10 +0000212 Fn->setDoesNotThrow();
213
Anders Carlsson9dc046e2010-06-08 22:40:05 +0000214 return Fn;
215}
216
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000217void
John McCall3030eb82010-11-06 09:44:32 +0000218CodeGenModule::EmitCXXGlobalVarDeclInitFunc(const VarDecl *D,
Richard Smith7ca48502012-02-13 22:16:19 +0000219 llvm::GlobalVariable *Addr,
220 bool PerformInit) {
Chris Lattner8b418682012-02-07 00:39:47 +0000221 llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
Eli Friedman6c6bda32010-01-08 00:50:11 +0000222
223 // Create a variable initialization function.
224 llvm::Function *Fn =
Anders Carlsson9dc046e2010-06-08 22:40:05 +0000225 CreateGlobalInitOrDestructFunction(*this, FTy, "__cxx_global_var_init");
Eli Friedman6c6bda32010-01-08 00:50:11 +0000226
Richard Smith7ca48502012-02-13 22:16:19 +0000227 CodeGenFunction(*this).GenerateCXXGlobalVarDeclInitFunc(Fn, D, Addr,
228 PerformInit);
Eli Friedman6c6bda32010-01-08 00:50:11 +0000229
Fariborz Jahanian9f967c52010-06-21 18:45:05 +0000230 if (D->hasAttr<InitPriorityAttr>()) {
231 unsigned int order = D->getAttr<InitPriorityAttr>()->getPriority();
Chris Lattnerec2830d2010-06-27 06:32:58 +0000232 OrderGlobalInits Key(order, PrioritizedCXXGlobalInits.size());
Fariborz Jahaniane0b691a2010-06-21 21:27:42 +0000233 PrioritizedCXXGlobalInits.push_back(std::make_pair(Key, Fn));
John McCallbf40cb52010-07-15 23:40:35 +0000234 DelayedCXXInitPosition.erase(D);
Fariborz Jahanian9f967c52010-06-21 18:45:05 +0000235 }
John McCallbf40cb52010-07-15 23:40:35 +0000236 else {
237 llvm::DenseMap<const Decl *, unsigned>::iterator I =
238 DelayedCXXInitPosition.find(D);
239 if (I == DelayedCXXInitPosition.end()) {
240 CXXGlobalInits.push_back(Fn);
241 } else {
242 assert(CXXGlobalInits[I->second] == 0);
243 CXXGlobalInits[I->second] = Fn;
244 DelayedCXXInitPosition.erase(I);
245 }
246 }
Eli Friedman6c6bda32010-01-08 00:50:11 +0000247}
248
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000249void
250CodeGenModule::EmitCXXGlobalInitFunc() {
John McCallbf40cb52010-07-15 23:40:35 +0000251 while (!CXXGlobalInits.empty() && !CXXGlobalInits.back())
252 CXXGlobalInits.pop_back();
253
Fariborz Jahanian9f967c52010-06-21 18:45:05 +0000254 if (CXXGlobalInits.empty() && PrioritizedCXXGlobalInits.empty())
Anders Carlssoneb4072e2009-12-10 00:30:05 +0000255 return;
256
Chris Lattner8b418682012-02-07 00:39:47 +0000257 llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
Anders Carlssoneb4072e2009-12-10 00:30:05 +0000258
259 // Create our global initialization function.
Anders Carlsson9dc046e2010-06-08 22:40:05 +0000260 llvm::Function *Fn =
261 CreateGlobalInitOrDestructFunction(*this, FTy, "_GLOBAL__I_a");
Anders Carlssoneb4072e2009-12-10 00:30:05 +0000262
Fariborz Jahanian9f967c52010-06-21 18:45:05 +0000263 if (!PrioritizedCXXGlobalInits.empty()) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000264 SmallVector<llvm::Constant*, 8> LocalCXXGlobalInits;
Fariborz Jahanian027d7ed2010-06-21 19:49:38 +0000265 llvm::array_pod_sort(PrioritizedCXXGlobalInits.begin(),
Fariborz Jahanianf4896882010-06-22 00:23:08 +0000266 PrioritizedCXXGlobalInits.end());
Fariborz Jahanian9f967c52010-06-21 18:45:05 +0000267 for (unsigned i = 0; i < PrioritizedCXXGlobalInits.size(); i++) {
268 llvm::Function *Fn = PrioritizedCXXGlobalInits[i].second;
269 LocalCXXGlobalInits.push_back(Fn);
270 }
John McCallbf40cb52010-07-15 23:40:35 +0000271 LocalCXXGlobalInits.append(CXXGlobalInits.begin(), CXXGlobalInits.end());
Fariborz Jahanian9f967c52010-06-21 18:45:05 +0000272 CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn,
273 &LocalCXXGlobalInits[0],
274 LocalCXXGlobalInits.size());
275 }
276 else
277 CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn,
278 &CXXGlobalInits[0],
279 CXXGlobalInits.size());
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000280 AddGlobalCtor(Fn);
Axel Naumann54ec6c52011-05-06 15:24:04 +0000281 CXXGlobalInits.clear();
282 PrioritizedCXXGlobalInits.clear();
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000283}
284
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000285void CodeGenModule::EmitCXXGlobalDtorFunc() {
286 if (CXXGlobalDtors.empty())
287 return;
288
Chris Lattner8b418682012-02-07 00:39:47 +0000289 llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000290
291 // Create our global destructor function.
292 llvm::Function *Fn =
Anders Carlsson9dc046e2010-06-08 22:40:05 +0000293 CreateGlobalInitOrDestructFunction(*this, FTy, "_GLOBAL__D_a");
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000294
295 CodeGenFunction(*this).GenerateCXXGlobalDtorFunc(Fn, CXXGlobalDtors);
296 AddGlobalDtor(Fn);
297}
298
John McCall3030eb82010-11-06 09:44:32 +0000299/// Emit the code necessary to initialize the given global variable.
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000300void CodeGenFunction::GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn,
John McCall3030eb82010-11-06 09:44:32 +0000301 const VarDecl *D,
Richard Smith7ca48502012-02-13 22:16:19 +0000302 llvm::GlobalVariable *Addr,
303 bool PerformInit) {
John McCalld26bc762011-03-09 04:27:21 +0000304 StartFunction(GlobalDecl(), getContext().VoidTy, Fn,
John McCallde5d3c72012-02-17 03:33:10 +0000305 getTypes().arrangeNullaryFunction(),
John McCalld26bc762011-03-09 04:27:21 +0000306 FunctionArgList(), SourceLocation());
Daniel Dunbar5c6846e2010-03-20 04:15:29 +0000307
Douglas Gregore67d1512011-07-01 21:54:36 +0000308 // Use guarded initialization if the global variable is weak. This
309 // occurs for, e.g., instantiated static data members and
310 // definitions explicitly marked weak.
311 if (Addr->getLinkage() == llvm::GlobalValue::WeakODRLinkage ||
312 Addr->getLinkage() == llvm::GlobalValue::WeakAnyLinkage) {
Richard Smith7ca48502012-02-13 22:16:19 +0000313 EmitCXXGuardedInit(*D, Addr, PerformInit);
John McCall3030eb82010-11-06 09:44:32 +0000314 } else {
Richard Smith7ca48502012-02-13 22:16:19 +0000315 EmitCXXGlobalVarDeclInit(*D, Addr, PerformInit);
Fariborz Jahanian92d835a2010-10-26 22:47:47 +0000316 }
Daniel Dunbar5c6846e2010-03-20 04:15:29 +0000317
318 FinishFunction();
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000319}
Daniel Dunbar5c6846e2010-03-20 04:15:29 +0000320
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000321void CodeGenFunction::GenerateCXXGlobalInitFunc(llvm::Function *Fn,
322 llvm::Constant **Decls,
323 unsigned NumDecls) {
John McCalld26bc762011-03-09 04:27:21 +0000324 StartFunction(GlobalDecl(), getContext().VoidTy, Fn,
John McCallde5d3c72012-02-17 03:33:10 +0000325 getTypes().arrangeNullaryFunction(),
John McCalld26bc762011-03-09 04:27:21 +0000326 FunctionArgList(), SourceLocation());
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000327
John McCallf85e1932011-06-15 23:02:42 +0000328 RunCleanupsScope Scope(*this);
329
330 // When building in Objective-C++ ARC mode, create an autorelease pool
331 // around the global initializers.
David Blaikie4e4d0842012-03-11 07:00:24 +0000332 if (getLangOpts().ObjCAutoRefCount && getLangOpts().CPlusPlus) {
John McCallf85e1932011-06-15 23:02:42 +0000333 llvm::Value *token = EmitObjCAutoreleasePoolPush();
334 EmitObjCAutoreleasePoolCleanup(token);
335 }
336
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000337 for (unsigned i = 0; i != NumDecls; ++i)
John McCallbf40cb52010-07-15 23:40:35 +0000338 if (Decls[i])
John McCallf85e1932011-06-15 23:02:42 +0000339 Builder.CreateCall(Decls[i]);
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000340
John McCallf85e1932011-06-15 23:02:42 +0000341 Scope.ForceCleanup();
342
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000343 FinishFunction();
344}
345
346void CodeGenFunction::GenerateCXXGlobalDtorFunc(llvm::Function *Fn,
Chris Lattner810112e2010-06-19 05:52:45 +0000347 const std::vector<std::pair<llvm::WeakVH, llvm::Constant*> >
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000348 &DtorsAndObjects) {
John McCalld26bc762011-03-09 04:27:21 +0000349 StartFunction(GlobalDecl(), getContext().VoidTy, Fn,
John McCallde5d3c72012-02-17 03:33:10 +0000350 getTypes().arrangeNullaryFunction(),
John McCalld26bc762011-03-09 04:27:21 +0000351 FunctionArgList(), SourceLocation());
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000352
353 // Emit the dtors, in reverse order from construction.
Chris Lattnerc9a85f92010-04-26 20:35:54 +0000354 for (unsigned i = 0, e = DtorsAndObjects.size(); i != e; ++i) {
Chris Lattner810112e2010-06-19 05:52:45 +0000355 llvm::Value *Callee = DtorsAndObjects[e - i - 1].first;
Chris Lattnerc9a85f92010-04-26 20:35:54 +0000356 llvm::CallInst *CI = Builder.CreateCall(Callee,
357 DtorsAndObjects[e - i - 1].second);
358 // Make sure the call and the callee agree on calling convention.
359 if (llvm::Function *F = dyn_cast<llvm::Function>(Callee))
360 CI->setCallingConv(F->getCallingConv());
361 }
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000362
363 FinishFunction();
Anders Carlssoneb4072e2009-12-10 00:30:05 +0000364}
365
John McCalla91f6662011-07-13 03:01:35 +0000366/// generateDestroyHelper - Generates a helper function which, when
367/// invoked, destroys the given object.
Anders Carlsson77291362010-06-08 22:17:27 +0000368llvm::Function *
John McCalla91f6662011-07-13 03:01:35 +0000369CodeGenFunction::generateDestroyHelper(llvm::Constant *addr,
370 QualType type,
Peter Collingbourne516bbd42012-01-26 03:33:36 +0000371 Destroyer *destroyer,
John McCalla91f6662011-07-13 03:01:35 +0000372 bool useEHCleanupForArray) {
John McCalld26bc762011-03-09 04:27:21 +0000373 FunctionArgList args;
374 ImplicitParamDecl dst(0, SourceLocation(), 0, getContext().VoidPtrTy);
375 args.push_back(&dst);
Anders Carlsson77291362010-06-08 22:17:27 +0000376
Anders Carlsson77291362010-06-08 22:17:27 +0000377 const CGFunctionInfo &FI =
John McCallde5d3c72012-02-17 03:33:10 +0000378 CGM.getTypes().arrangeFunctionDeclaration(getContext().VoidTy, args,
379 FunctionType::ExtInfo(),
380 /*variadic*/ false);
381 llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI);
John McCalla91f6662011-07-13 03:01:35 +0000382 llvm::Function *fn =
Anders Carlsson9dc046e2010-06-08 22:40:05 +0000383 CreateGlobalInitOrDestructFunction(CGM, FTy, "__cxx_global_array_dtor");
Anders Carlsson77291362010-06-08 22:17:27 +0000384
John McCalla91f6662011-07-13 03:01:35 +0000385 StartFunction(GlobalDecl(), getContext().VoidTy, fn, FI, args,
John McCalld26bc762011-03-09 04:27:21 +0000386 SourceLocation());
Anders Carlsson77291362010-06-08 22:17:27 +0000387
John McCalla91f6662011-07-13 03:01:35 +0000388 emitDestroy(addr, type, destroyer, useEHCleanupForArray);
Anders Carlsson77291362010-06-08 22:17:27 +0000389
390 FinishFunction();
391
John McCalla91f6662011-07-13 03:01:35 +0000392 return fn;
Anders Carlsson77291362010-06-08 22:17:27 +0000393}