blob: 3b8f830278b2edbdf5dd71517b26550ad4039679 [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
John McCalla07398e2011-06-16 04:16:24 +000031 unsigned alignment = Context.getDeclAlign(&D).getQuantity();
32 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 McCall7c2349b2011-08-25 20:40:09 +000049 CGF.EmitAggExpr(Init, AggValueSlot::forLValue(lv,AggValueSlot::IsDestructed,
John McCall410ffb22011-08-25 23:04:34 +000050 AggValueSlot::DoesNotNeedGCBarriers,
51 AggValueSlot::IsNotAliased));
Anders Carlsson5ec2e7c2009-12-10 00:16:00 +000052 }
53}
54
John McCall5cd91b52010-09-08 01:44:27 +000055/// Emit code to cause the destruction of the given variable with
56/// static storage duration.
Douglas Gregorcc6a44b2010-05-05 15:38:32 +000057static void EmitDeclDestroy(CodeGenFunction &CGF, const VarDecl &D,
John McCalla91f6662011-07-13 03:01:35 +000058 llvm::Constant *addr) {
Douglas Gregorcc6a44b2010-05-05 15:38:32 +000059 CodeGenModule &CGM = CGF.CGM;
John McCalla91f6662011-07-13 03:01:35 +000060
61 // FIXME: __attribute__((cleanup)) ?
Douglas Gregorcc6a44b2010-05-05 15:38:32 +000062
John McCalla91f6662011-07-13 03:01:35 +000063 QualType type = D.getType();
64 QualType::DestructionKind dtorKind = type.isDestructedType();
65
66 switch (dtorKind) {
67 case QualType::DK_none:
Douglas Gregorcc6a44b2010-05-05 15:38:32 +000068 return;
John McCalla91f6662011-07-13 03:01:35 +000069
70 case QualType::DK_cxx_destructor:
71 break;
72
73 case QualType::DK_objc_strong_lifetime:
74 case QualType::DK_objc_weak_lifetime:
75 // We don't care about releasing objects during process teardown.
Douglas Gregorcc6a44b2010-05-05 15:38:32 +000076 return;
John McCalla91f6662011-07-13 03:01:35 +000077 }
78
79 llvm::Constant *function;
80 llvm::Constant *argument;
81
82 // Special-case non-array C++ destructors, where there's a function
83 // with the right signature that we can just call.
84 const CXXRecordDecl *record = 0;
85 if (dtorKind == QualType::DK_cxx_destructor &&
86 (record = type->getAsCXXRecordDecl())) {
87 assert(!record->hasTrivialDestructor());
88 CXXDestructorDecl *dtor = record->getDestructor();
89
90 function = CGM.GetAddrOfCXXDestructor(dtor, Dtor_Complete);
91 argument = addr;
92
93 // Otherwise, the standard logic requires a helper function.
94 } else {
95 function = CodeGenFunction(CGM).generateDestroyHelper(addr, type,
96 CGF.getDestroyer(dtorKind),
97 CGF.needsEHCleanup(dtorKind));
98 argument = llvm::Constant::getNullValue(CGF.Int8PtrTy);
99 }
100
101 CGF.EmitCXXGlobalDtorRegistration(function, argument);
Douglas Gregorcc6a44b2010-05-05 15:38:32 +0000102}
103
Anders Carlssonfcbfdc12009-12-10 00:57:45 +0000104void CodeGenFunction::EmitCXXGlobalVarDeclInit(const VarDecl &D,
105 llvm::Constant *DeclPtr) {
106
107 const Expr *Init = D.getInit();
108 QualType T = D.getType();
109
110 if (!T->isReferenceType()) {
111 EmitDeclInit(*this, D, DeclPtr);
Douglas Gregorcc6a44b2010-05-05 15:38:32 +0000112 EmitDeclDestroy(*this, D, DeclPtr);
Anders Carlssonfcbfdc12009-12-10 00:57:45 +0000113 return;
114 }
Anders Carlsson045a6d82010-06-27 17:52:15 +0000115
Daniel Dunbar91a16fa2010-08-21 02:24:36 +0000116 unsigned Alignment = getContext().getDeclAlign(&D).getQuantity();
Anders Carlsson045a6d82010-06-27 17:52:15 +0000117 RValue RV = EmitReferenceBindingToExpr(Init, &D);
Daniel Dunbar91a16fa2010-08-21 02:24:36 +0000118 EmitStoreOfScalar(RV.getScalarVal(), DeclPtr, false, Alignment, T);
Anders Carlssonfcbfdc12009-12-10 00:57:45 +0000119}
Anders Carlssoneb4072e2009-12-10 00:30:05 +0000120
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000121void
122CodeGenFunction::EmitCXXGlobalDtorRegistration(llvm::Constant *DtorFn,
123 llvm::Constant *DeclPtr) {
124 // Generate a global destructor entry if not using __cxa_atexit.
125 if (!CGM.getCodeGenOpts().CXAAtExit) {
126 CGM.AddCXXDtorEntry(DtorFn, DeclPtr);
127 return;
128 }
129
Anders Carlssoneb4072e2009-12-10 00:30:05 +0000130 // Get the destructor function type
Chris Lattner9cbe4f02011-07-09 17:41:47 +0000131 llvm::Type *DtorFnTy =
John McCalld16c2cf2011-02-08 08:22:06 +0000132 llvm::FunctionType::get(llvm::Type::getVoidTy(getLLVMContext()),
Jay Foadda549e82011-07-29 13:56:53 +0000133 Int8PtrTy, false);
Anders Carlssoneb4072e2009-12-10 00:30:05 +0000134 DtorFnTy = llvm::PointerType::getUnqual(DtorFnTy);
135
Chris Lattner9cbe4f02011-07-09 17:41:47 +0000136 llvm::Type *Params[] = { DtorFnTy, Int8PtrTy, Int8PtrTy };
Anders Carlssoneb4072e2009-12-10 00:30:05 +0000137
138 // Get the __cxa_atexit function type
139 // extern "C" int __cxa_atexit ( void (*f)(void *), void *p, void *d );
Chris Lattner2acc6e32011-07-18 04:24:23 +0000140 llvm::FunctionType *AtExitFnTy =
Anders Carlssoneb4072e2009-12-10 00:30:05 +0000141 llvm::FunctionType::get(ConvertType(getContext().IntTy), Params, false);
142
143 llvm::Constant *AtExitFn = CGM.CreateRuntimeFunction(AtExitFnTy,
144 "__cxa_atexit");
Anders Carlssonbd4a0732011-03-20 20:52:32 +0000145 if (llvm::Function *Fn = dyn_cast<llvm::Function>(AtExitFn))
146 Fn->setDoesNotThrow();
Anders Carlssoneb4072e2009-12-10 00:30:05 +0000147
148 llvm::Constant *Handle = CGM.CreateRuntimeVariable(Int8PtrTy,
149 "__dso_handle");
150 llvm::Value *Args[3] = { llvm::ConstantExpr::getBitCast(DtorFn, DtorFnTy),
151 llvm::ConstantExpr::getBitCast(DeclPtr, Int8PtrTy),
152 llvm::ConstantExpr::getBitCast(Handle, Int8PtrTy) };
Jay Foad4c7d9f12011-07-15 08:37:34 +0000153 Builder.CreateCall(AtExitFn, Args);
Anders Carlssoneb4072e2009-12-10 00:30:05 +0000154}
155
John McCall3030eb82010-11-06 09:44:32 +0000156void CodeGenFunction::EmitCXXGuardedInit(const VarDecl &D,
157 llvm::GlobalVariable *DeclPtr) {
John McCall32096692011-03-18 02:56:14 +0000158 // If we've been asked to forbid guard variables, emit an error now.
159 // This diagnostic is hard-coded for Darwin's use case; we can find
160 // better phrasing if someone else needs it.
161 if (CGM.getCodeGenOpts().ForbidGuardVariables)
162 CGM.Error(D.getLocation(),
163 "this initialization requires a guard variable, which "
164 "the kernel does not support");
165
John McCall3030eb82010-11-06 09:44:32 +0000166 CGM.getCXXABI().EmitGuardedInit(*this, D, DeclPtr);
John McCall5cd91b52010-09-08 01:44:27 +0000167}
168
Anders Carlsson9dc046e2010-06-08 22:40:05 +0000169static llvm::Function *
170CreateGlobalInitOrDestructFunction(CodeGenModule &CGM,
Chris Lattner2acc6e32011-07-18 04:24:23 +0000171 llvm::FunctionType *FTy,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000172 StringRef Name) {
Anders Carlsson9dc046e2010-06-08 22:40:05 +0000173 llvm::Function *Fn =
174 llvm::Function::Create(FTy, llvm::GlobalValue::InternalLinkage,
175 Name, &CGM.getModule());
Fariborz Jahaniand6c9a0f2011-02-15 18:54:46 +0000176 if (!CGM.getContext().getLangOptions().AppleKext) {
177 // Set the section if needed.
178 if (const char *Section =
Douglas Gregorbcfd1f52011-09-02 00:18:52 +0000179 CGM.getContext().getTargetInfo().getStaticInitSectionSpecifier())
Fariborz Jahaniand6c9a0f2011-02-15 18:54:46 +0000180 Fn->setSection(Section);
181 }
Anders Carlsson18af3682010-06-08 22:47:50 +0000182
Anders Carlsson7a178512011-02-28 00:33:03 +0000183 if (!CGM.getLangOptions().Exceptions)
John McCall044cc542010-07-06 04:38:10 +0000184 Fn->setDoesNotThrow();
185
Anders Carlsson9dc046e2010-06-08 22:40:05 +0000186 return Fn;
187}
188
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000189void
John McCall3030eb82010-11-06 09:44:32 +0000190CodeGenModule::EmitCXXGlobalVarDeclInitFunc(const VarDecl *D,
191 llvm::GlobalVariable *Addr) {
Chris Lattner2acc6e32011-07-18 04:24:23 +0000192 llvm::FunctionType *FTy
Eli Friedman6c6bda32010-01-08 00:50:11 +0000193 = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
194 false);
195
196 // Create a variable initialization function.
197 llvm::Function *Fn =
Anders Carlsson9dc046e2010-06-08 22:40:05 +0000198 CreateGlobalInitOrDestructFunction(*this, FTy, "__cxx_global_var_init");
Eli Friedman6c6bda32010-01-08 00:50:11 +0000199
John McCall3030eb82010-11-06 09:44:32 +0000200 CodeGenFunction(*this).GenerateCXXGlobalVarDeclInitFunc(Fn, D, Addr);
Eli Friedman6c6bda32010-01-08 00:50:11 +0000201
Fariborz Jahanian9f967c52010-06-21 18:45:05 +0000202 if (D->hasAttr<InitPriorityAttr>()) {
203 unsigned int order = D->getAttr<InitPriorityAttr>()->getPriority();
Chris Lattnerec2830d2010-06-27 06:32:58 +0000204 OrderGlobalInits Key(order, PrioritizedCXXGlobalInits.size());
Fariborz Jahaniane0b691a2010-06-21 21:27:42 +0000205 PrioritizedCXXGlobalInits.push_back(std::make_pair(Key, Fn));
John McCallbf40cb52010-07-15 23:40:35 +0000206 DelayedCXXInitPosition.erase(D);
Fariborz Jahanian9f967c52010-06-21 18:45:05 +0000207 }
John McCallbf40cb52010-07-15 23:40:35 +0000208 else {
209 llvm::DenseMap<const Decl *, unsigned>::iterator I =
210 DelayedCXXInitPosition.find(D);
211 if (I == DelayedCXXInitPosition.end()) {
212 CXXGlobalInits.push_back(Fn);
213 } else {
214 assert(CXXGlobalInits[I->second] == 0);
215 CXXGlobalInits[I->second] = Fn;
216 DelayedCXXInitPosition.erase(I);
217 }
218 }
Eli Friedman6c6bda32010-01-08 00:50:11 +0000219}
220
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000221void
222CodeGenModule::EmitCXXGlobalInitFunc() {
John McCallbf40cb52010-07-15 23:40:35 +0000223 while (!CXXGlobalInits.empty() && !CXXGlobalInits.back())
224 CXXGlobalInits.pop_back();
225
Fariborz Jahanian9f967c52010-06-21 18:45:05 +0000226 if (CXXGlobalInits.empty() && PrioritizedCXXGlobalInits.empty())
Anders Carlssoneb4072e2009-12-10 00:30:05 +0000227 return;
228
Chris Lattner2acc6e32011-07-18 04:24:23 +0000229 llvm::FunctionType *FTy
Anders Carlssoneb4072e2009-12-10 00:30:05 +0000230 = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
231 false);
232
233 // Create our global initialization function.
Anders Carlsson9dc046e2010-06-08 22:40:05 +0000234 llvm::Function *Fn =
235 CreateGlobalInitOrDestructFunction(*this, FTy, "_GLOBAL__I_a");
Anders Carlssoneb4072e2009-12-10 00:30:05 +0000236
Fariborz Jahanian9f967c52010-06-21 18:45:05 +0000237 if (!PrioritizedCXXGlobalInits.empty()) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000238 SmallVector<llvm::Constant*, 8> LocalCXXGlobalInits;
Fariborz Jahanian027d7ed2010-06-21 19:49:38 +0000239 llvm::array_pod_sort(PrioritizedCXXGlobalInits.begin(),
Fariborz Jahanianf4896882010-06-22 00:23:08 +0000240 PrioritizedCXXGlobalInits.end());
Fariborz Jahanian9f967c52010-06-21 18:45:05 +0000241 for (unsigned i = 0; i < PrioritizedCXXGlobalInits.size(); i++) {
242 llvm::Function *Fn = PrioritizedCXXGlobalInits[i].second;
243 LocalCXXGlobalInits.push_back(Fn);
244 }
John McCallbf40cb52010-07-15 23:40:35 +0000245 LocalCXXGlobalInits.append(CXXGlobalInits.begin(), CXXGlobalInits.end());
Fariborz Jahanian9f967c52010-06-21 18:45:05 +0000246 CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn,
247 &LocalCXXGlobalInits[0],
248 LocalCXXGlobalInits.size());
249 }
250 else
251 CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn,
252 &CXXGlobalInits[0],
253 CXXGlobalInits.size());
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000254 AddGlobalCtor(Fn);
Axel Naumann54ec6c52011-05-06 15:24:04 +0000255 CXXGlobalInits.clear();
256 PrioritizedCXXGlobalInits.clear();
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000257}
258
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000259void CodeGenModule::EmitCXXGlobalDtorFunc() {
260 if (CXXGlobalDtors.empty())
261 return;
262
Chris Lattner2acc6e32011-07-18 04:24:23 +0000263 llvm::FunctionType *FTy
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000264 = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
265 false);
266
267 // Create our global destructor function.
268 llvm::Function *Fn =
Anders Carlsson9dc046e2010-06-08 22:40:05 +0000269 CreateGlobalInitOrDestructFunction(*this, FTy, "_GLOBAL__D_a");
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000270
271 CodeGenFunction(*this).GenerateCXXGlobalDtorFunc(Fn, CXXGlobalDtors);
272 AddGlobalDtor(Fn);
273}
274
John McCall3030eb82010-11-06 09:44:32 +0000275/// Emit the code necessary to initialize the given global variable.
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000276void CodeGenFunction::GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn,
John McCall3030eb82010-11-06 09:44:32 +0000277 const VarDecl *D,
278 llvm::GlobalVariable *Addr) {
John McCalld26bc762011-03-09 04:27:21 +0000279 StartFunction(GlobalDecl(), getContext().VoidTy, Fn,
280 getTypes().getNullaryFunctionInfo(),
281 FunctionArgList(), SourceLocation());
Daniel Dunbar5c6846e2010-03-20 04:15:29 +0000282
Douglas Gregore67d1512011-07-01 21:54:36 +0000283 // Use guarded initialization if the global variable is weak. This
284 // occurs for, e.g., instantiated static data members and
285 // definitions explicitly marked weak.
286 if (Addr->getLinkage() == llvm::GlobalValue::WeakODRLinkage ||
287 Addr->getLinkage() == llvm::GlobalValue::WeakAnyLinkage) {
John McCall3030eb82010-11-06 09:44:32 +0000288 EmitCXXGuardedInit(*D, Addr);
289 } else {
290 EmitCXXGlobalVarDeclInit(*D, Addr);
Fariborz Jahanian92d835a2010-10-26 22:47:47 +0000291 }
Daniel Dunbar5c6846e2010-03-20 04:15:29 +0000292
293 FinishFunction();
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000294}
Daniel Dunbar5c6846e2010-03-20 04:15:29 +0000295
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000296void CodeGenFunction::GenerateCXXGlobalInitFunc(llvm::Function *Fn,
297 llvm::Constant **Decls,
298 unsigned NumDecls) {
John McCalld26bc762011-03-09 04:27:21 +0000299 StartFunction(GlobalDecl(), getContext().VoidTy, Fn,
300 getTypes().getNullaryFunctionInfo(),
301 FunctionArgList(), SourceLocation());
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000302
John McCallf85e1932011-06-15 23:02:42 +0000303 RunCleanupsScope Scope(*this);
304
305 // When building in Objective-C++ ARC mode, create an autorelease pool
306 // around the global initializers.
307 if (getLangOptions().ObjCAutoRefCount && getLangOptions().CPlusPlus) {
308 llvm::Value *token = EmitObjCAutoreleasePoolPush();
309 EmitObjCAutoreleasePoolCleanup(token);
310 }
311
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000312 for (unsigned i = 0; i != NumDecls; ++i)
John McCallbf40cb52010-07-15 23:40:35 +0000313 if (Decls[i])
John McCallf85e1932011-06-15 23:02:42 +0000314 Builder.CreateCall(Decls[i]);
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000315
John McCallf85e1932011-06-15 23:02:42 +0000316 Scope.ForceCleanup();
317
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000318 FinishFunction();
319}
320
321void CodeGenFunction::GenerateCXXGlobalDtorFunc(llvm::Function *Fn,
Chris Lattner810112e2010-06-19 05:52:45 +0000322 const std::vector<std::pair<llvm::WeakVH, llvm::Constant*> >
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000323 &DtorsAndObjects) {
John McCalld26bc762011-03-09 04:27:21 +0000324 StartFunction(GlobalDecl(), getContext().VoidTy, Fn,
325 getTypes().getNullaryFunctionInfo(),
326 FunctionArgList(), SourceLocation());
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000327
328 // Emit the dtors, in reverse order from construction.
Chris Lattnerc9a85f92010-04-26 20:35:54 +0000329 for (unsigned i = 0, e = DtorsAndObjects.size(); i != e; ++i) {
Chris Lattner810112e2010-06-19 05:52:45 +0000330 llvm::Value *Callee = DtorsAndObjects[e - i - 1].first;
Chris Lattnerc9a85f92010-04-26 20:35:54 +0000331 llvm::CallInst *CI = Builder.CreateCall(Callee,
332 DtorsAndObjects[e - i - 1].second);
333 // Make sure the call and the callee agree on calling convention.
334 if (llvm::Function *F = dyn_cast<llvm::Function>(Callee))
335 CI->setCallingConv(F->getCallingConv());
336 }
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000337
338 FinishFunction();
Anders Carlssoneb4072e2009-12-10 00:30:05 +0000339}
340
John McCalla91f6662011-07-13 03:01:35 +0000341/// generateDestroyHelper - Generates a helper function which, when
342/// invoked, destroys the given object.
Anders Carlsson77291362010-06-08 22:17:27 +0000343llvm::Function *
John McCalla91f6662011-07-13 03:01:35 +0000344CodeGenFunction::generateDestroyHelper(llvm::Constant *addr,
345 QualType type,
346 Destroyer &destroyer,
347 bool useEHCleanupForArray) {
John McCalld26bc762011-03-09 04:27:21 +0000348 FunctionArgList args;
349 ImplicitParamDecl dst(0, SourceLocation(), 0, getContext().VoidPtrTy);
350 args.push_back(&dst);
Anders Carlsson77291362010-06-08 22:17:27 +0000351
Anders Carlsson77291362010-06-08 22:17:27 +0000352 const CGFunctionInfo &FI =
John McCalld26bc762011-03-09 04:27:21 +0000353 CGM.getTypes().getFunctionInfo(getContext().VoidTy, args,
Anders Carlsson77291362010-06-08 22:17:27 +0000354 FunctionType::ExtInfo());
Chris Lattner2acc6e32011-07-18 04:24:23 +0000355 llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI, false);
John McCalla91f6662011-07-13 03:01:35 +0000356 llvm::Function *fn =
Anders Carlsson9dc046e2010-06-08 22:40:05 +0000357 CreateGlobalInitOrDestructFunction(CGM, FTy, "__cxx_global_array_dtor");
Anders Carlsson77291362010-06-08 22:17:27 +0000358
John McCalla91f6662011-07-13 03:01:35 +0000359 StartFunction(GlobalDecl(), getContext().VoidTy, fn, FI, args,
John McCalld26bc762011-03-09 04:27:21 +0000360 SourceLocation());
Anders Carlsson77291362010-06-08 22:17:27 +0000361
John McCalla91f6662011-07-13 03:01:35 +0000362 emitDestroy(addr, type, destroyer, useEHCleanupForArray);
Anders Carlsson77291362010-06-08 22:17:27 +0000363
364 FinishFunction();
365
John McCalla91f6662011-07-13 03:01:35 +0000366 return fn;
Anders Carlsson77291362010-06-08 22:17:27 +0000367}
John McCalla91f6662011-07-13 03:01:35 +0000368