1 //===--- CGDeclCXX.cpp - Emit LLVM Code for C++ declarations --------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This contains code dealing with code generation of C++ declarations
12 //===----------------------------------------------------------------------===//
14 #include "CodeGenFunction.h"
16 #include "CGObjCRuntime.h"
17 #include "clang/Frontend/CodeGenOptions.h"
18 #include "llvm/ADT/StringExtras.h"
19 #include "llvm/IR/Intrinsics.h"
21 using namespace clang;
22 using namespace CodeGen;
24 static void EmitDeclInit(CodeGenFunction &CGF, const VarDecl &D,
25 llvm::Constant *DeclPtr) {
26 assert(D.hasGlobalStorage() && "VarDecl must have global storage!");
27 assert(!D.getType()->isReferenceType() &&
28 "Should not call EmitDeclInit on a reference!");
30 ASTContext &Context = CGF.getContext();
32 CharUnits alignment = Context.getDeclAlign(&D);
33 QualType type = D.getType();
34 LValue lv = CGF.MakeAddrLValue(DeclPtr, type, alignment);
36 const Expr *Init = D.getInit();
37 switch (CGF.getEvaluationKind(type)) {
39 CodeGenModule &CGM = CGF.CGM;
40 if (lv.isObjCStrong())
41 CGM.getObjCRuntime().EmitObjCGlobalAssign(CGF, CGF.EmitScalarExpr(Init),
42 DeclPtr, D.getTLSKind());
43 else if (lv.isObjCWeak())
44 CGM.getObjCRuntime().EmitObjCWeakAssign(CGF, CGF.EmitScalarExpr(Init),
47 CGF.EmitScalarInit(Init, &D, lv, false);
51 CGF.EmitComplexExprIntoLValue(Init, lv, /*isInit*/ true);
54 CGF.EmitAggExpr(Init, AggValueSlot::forLValue(lv,AggValueSlot::IsDestructed,
55 AggValueSlot::DoesNotNeedGCBarriers,
56 AggValueSlot::IsNotAliased));
59 llvm_unreachable("bad evaluation kind");
62 /// Emit code to cause the destruction of the given variable with
63 /// static storage duration.
64 static void EmitDeclDestroy(CodeGenFunction &CGF, const VarDecl &D,
65 llvm::Constant *addr) {
66 CodeGenModule &CGM = CGF.CGM;
68 // FIXME: __attribute__((cleanup)) ?
70 QualType type = D.getType();
71 QualType::DestructionKind dtorKind = type.isDestructedType();
74 case QualType::DK_none:
77 case QualType::DK_cxx_destructor:
80 case QualType::DK_objc_strong_lifetime:
81 case QualType::DK_objc_weak_lifetime:
82 // We don't care about releasing objects during process teardown.
83 assert(!D.getTLSKind() && "should have rejected this");
87 llvm::Constant *function;
88 llvm::Constant *argument;
90 // Special-case non-array C++ destructors, where there's a function
91 // with the right signature that we can just call.
92 const CXXRecordDecl *record = 0;
93 if (dtorKind == QualType::DK_cxx_destructor &&
94 (record = type->getAsCXXRecordDecl())) {
95 assert(!record->hasTrivialDestructor());
96 CXXDestructorDecl *dtor = record->getDestructor();
98 function = CGM.GetAddrOfCXXDestructor(dtor, Dtor_Complete);
101 // Otherwise, the standard logic requires a helper function.
103 function = CodeGenFunction(CGM).generateDestroyHelper(addr, type,
104 CGF.getDestroyer(dtorKind),
105 CGF.needsEHCleanup(dtorKind));
106 argument = llvm::Constant::getNullValue(CGF.Int8PtrTy);
109 CGM.getCXXABI().registerGlobalDtor(CGF, D, function, argument);
112 /// Emit code to cause the variable at the given address to be considered as
113 /// constant from this point onwards.
114 static void EmitDeclInvariant(CodeGenFunction &CGF, const VarDecl &D,
115 llvm::Constant *Addr) {
116 // Don't emit the intrinsic if we're not optimizing.
117 if (!CGF.CGM.getCodeGenOpts().OptimizationLevel)
120 // Grab the llvm.invariant.start intrinsic.
121 llvm::Intrinsic::ID InvStartID = llvm::Intrinsic::invariant_start;
122 llvm::Constant *InvariantStart = CGF.CGM.getIntrinsic(InvStartID);
124 // Emit a call with the size in bytes of the object.
125 CharUnits WidthChars = CGF.getContext().getTypeSizeInChars(D.getType());
126 uint64_t Width = WidthChars.getQuantity();
127 llvm::Value *Args[2] = { llvm::ConstantInt::getSigned(CGF.Int64Ty, Width),
128 llvm::ConstantExpr::getBitCast(Addr, CGF.Int8PtrTy)};
129 CGF.Builder.CreateCall(InvariantStart, Args);
132 void CodeGenFunction::EmitCXXGlobalVarDeclInit(const VarDecl &D,
133 llvm::Constant *DeclPtr,
136 const Expr *Init = D.getInit();
137 QualType T = D.getType();
139 if (!T->isReferenceType()) {
141 EmitDeclInit(*this, D, DeclPtr);
142 if (CGM.isTypeConstant(D.getType(), true))
143 EmitDeclInvariant(*this, D, DeclPtr);
145 EmitDeclDestroy(*this, D, DeclPtr);
149 assert(PerformInit && "cannot have constant initializer which needs "
150 "destruction for reference");
151 unsigned Alignment = getContext().getDeclAlign(&D).getQuantity();
152 RValue RV = EmitReferenceBindingToExpr(Init, &D);
153 EmitStoreOfScalar(RV.getScalarVal(), DeclPtr, false, Alignment, T);
156 static llvm::Function *
157 CreateGlobalInitOrDestructFunction(CodeGenModule &CGM,
158 llvm::FunctionType *ty,
162 /// Create a stub function, suitable for being passed to atexit,
163 /// which passes the given address to the given destructor function.
164 static llvm::Constant *createAtExitStub(CodeGenModule &CGM,
165 llvm::Constant *dtor,
166 llvm::Constant *addr) {
167 // Get the destructor function type, void(*)(void).
168 llvm::FunctionType *ty = llvm::FunctionType::get(CGM.VoidTy, false);
170 CreateGlobalInitOrDestructFunction(CGM, ty,
171 Twine("__dtor_", addr->getName()));
173 CodeGenFunction CGF(CGM);
175 // Initialize debug info if needed.
176 CGF.maybeInitializeDebugInfo();
178 CGF.StartFunction(GlobalDecl(), CGM.getContext().VoidTy, fn,
179 CGM.getTypes().arrangeNullaryFunction(),
180 FunctionArgList(), SourceLocation());
182 llvm::CallInst *call = CGF.Builder.CreateCall(dtor, addr);
184 // Make sure the call and the callee agree on calling convention.
185 if (llvm::Function *dtorFn =
186 dyn_cast<llvm::Function>(dtor->stripPointerCasts()))
187 call->setCallingConv(dtorFn->getCallingConv());
189 CGF.FinishFunction();
194 /// Register a global destructor using the C atexit runtime function.
195 void CodeGenFunction::registerGlobalDtorWithAtExit(llvm::Constant *dtor,
196 llvm::Constant *addr) {
197 // Create a function which calls the destructor.
198 llvm::Constant *dtorStub = createAtExitStub(CGM, dtor, addr);
200 // extern "C" int atexit(void (*f)(void));
201 llvm::FunctionType *atexitTy =
202 llvm::FunctionType::get(IntTy, dtorStub->getType(), false);
204 llvm::Constant *atexit =
205 CGM.CreateRuntimeFunction(atexitTy, "atexit");
206 if (llvm::Function *atexitFn = dyn_cast<llvm::Function>(atexit))
207 atexitFn->setDoesNotThrow();
209 EmitNounwindRuntimeCall(atexit, dtorStub);
212 void CodeGenFunction::EmitCXXGuardedInit(const VarDecl &D,
213 llvm::GlobalVariable *DeclPtr,
215 // If we've been asked to forbid guard variables, emit an error now.
216 // This diagnostic is hard-coded for Darwin's use case; we can find
217 // better phrasing if someone else needs it.
218 if (CGM.getCodeGenOpts().ForbidGuardVariables)
219 CGM.Error(D.getLocation(),
220 "this initialization requires a guard variable, which "
221 "the kernel does not support");
223 CGM.getCXXABI().EmitGuardedInit(*this, D, DeclPtr, PerformInit);
226 static llvm::Function *
227 CreateGlobalInitOrDestructFunction(CodeGenModule &CGM,
228 llvm::FunctionType *FTy,
229 const Twine &Name, bool TLS) {
231 llvm::Function::Create(FTy, llvm::GlobalValue::InternalLinkage,
232 Name, &CGM.getModule());
233 if (!CGM.getLangOpts().AppleKext && !TLS) {
234 // Set the section if needed.
235 if (const char *Section =
236 CGM.getTarget().getStaticInitSectionSpecifier())
237 Fn->setSection(Section);
240 Fn->setCallingConv(CGM.getRuntimeCC());
242 if (!CGM.getLangOpts().Exceptions)
243 Fn->setDoesNotThrow();
245 if (CGM.getSanOpts().Address)
246 Fn->addFnAttr(llvm::Attribute::SanitizeAddress);
247 if (CGM.getSanOpts().Thread)
248 Fn->addFnAttr(llvm::Attribute::SanitizeThread);
249 if (CGM.getSanOpts().Memory)
250 Fn->addFnAttr(llvm::Attribute::SanitizeMemory);
256 CodeGenModule::EmitCXXGlobalVarDeclInitFunc(const VarDecl *D,
257 llvm::GlobalVariable *Addr,
259 llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
261 // Create a variable initialization function.
263 CreateGlobalInitOrDestructFunction(*this, FTy, "__cxx_global_var_init");
265 CodeGenFunction(*this).GenerateCXXGlobalVarDeclInitFunc(Fn, D, Addr,
268 if (D->getTLSKind()) {
269 // FIXME: Should we support init_priority for thread_local?
270 // FIXME: Ideally, initialization of instantiated thread_local static data
271 // members of class templates should not trigger initialization of other
272 // entities in the TU.
273 // FIXME: We only need to register one __cxa_thread_atexit function for the
275 CXXThreadLocalInits.push_back(Fn);
276 } else if (D->hasAttr<InitPriorityAttr>()) {
277 unsigned int order = D->getAttr<InitPriorityAttr>()->getPriority();
278 OrderGlobalInits Key(order, PrioritizedCXXGlobalInits.size());
279 PrioritizedCXXGlobalInits.push_back(std::make_pair(Key, Fn));
280 DelayedCXXInitPosition.erase(D);
282 llvm::DenseMap<const Decl *, unsigned>::iterator I =
283 DelayedCXXInitPosition.find(D);
284 if (I == DelayedCXXInitPosition.end()) {
285 CXXGlobalInits.push_back(Fn);
287 assert(CXXGlobalInits[I->second] == 0);
288 CXXGlobalInits[I->second] = Fn;
289 DelayedCXXInitPosition.erase(I);
294 void CodeGenModule::EmitCXXThreadLocalInitFunc() {
295 llvm::Function *InitFn = 0;
296 if (!CXXThreadLocalInits.empty()) {
297 // Generate a guarded initialization function.
298 llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
299 InitFn = CreateGlobalInitOrDestructFunction(*this, FTy, "__tls_init",
301 llvm::GlobalVariable *Guard = new llvm::GlobalVariable(
302 getModule(), Int8Ty, false, llvm::GlobalVariable::InternalLinkage,
303 llvm::ConstantInt::get(Int8Ty, 0), "__tls_guard");
304 Guard->setThreadLocal(true);
305 CodeGenFunction(*this)
306 .GenerateCXXGlobalInitFunc(InitFn, CXXThreadLocalInits, Guard);
309 getCXXABI().EmitThreadLocalInitFuncs(CXXThreadLocals, InitFn);
311 CXXThreadLocalInits.clear();
312 CXXThreadLocals.clear();
316 CodeGenModule::EmitCXXGlobalInitFunc() {
317 while (!CXXGlobalInits.empty() && !CXXGlobalInits.back())
318 CXXGlobalInits.pop_back();
320 if (CXXGlobalInits.empty() && PrioritizedCXXGlobalInits.empty())
323 llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
326 // Create our global initialization function.
327 if (!PrioritizedCXXGlobalInits.empty()) {
328 SmallVector<llvm::Constant*, 8> LocalCXXGlobalInits;
329 llvm::array_pod_sort(PrioritizedCXXGlobalInits.begin(),
330 PrioritizedCXXGlobalInits.end());
331 // Iterate over "chunks" of ctors with same priority and emit each chunk
332 // into separate function. Note - everything is sorted first by priority,
333 // second - by lex order, so we emit ctor functions in proper order.
334 for (SmallVectorImpl<GlobalInitData >::iterator
335 I = PrioritizedCXXGlobalInits.begin(),
336 E = PrioritizedCXXGlobalInits.end(); I != E; ) {
337 SmallVectorImpl<GlobalInitData >::iterator
338 PrioE = std::upper_bound(I + 1, E, *I, GlobalInitPriorityCmp());
340 LocalCXXGlobalInits.clear();
341 unsigned Priority = I->first.priority;
342 // Compute the function suffix from priority. Prepend with zeroes to make
343 // sure the function names are also ordered as priorities.
344 std::string PrioritySuffix = llvm::utostr(Priority);
345 // Priority is always <= 65535 (enforced by sema)..
346 PrioritySuffix = std::string(6-PrioritySuffix.size(), '0')+PrioritySuffix;
348 CreateGlobalInitOrDestructFunction(*this, FTy,
349 "_GLOBAL__I_" + PrioritySuffix);
351 for (; I < PrioE; ++I)
352 LocalCXXGlobalInits.push_back(I->second);
354 CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, LocalCXXGlobalInits);
355 AddGlobalCtor(Fn, Priority);
360 CreateGlobalInitOrDestructFunction(*this, FTy, "_GLOBAL__I_a");
362 CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, CXXGlobalInits);
365 CXXGlobalInits.clear();
366 PrioritizedCXXGlobalInits.clear();
369 void CodeGenModule::EmitCXXGlobalDtorFunc() {
370 if (CXXGlobalDtors.empty())
373 llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
375 // Create our global destructor function.
377 CreateGlobalInitOrDestructFunction(*this, FTy, "_GLOBAL__D_a");
379 CodeGenFunction(*this).GenerateCXXGlobalDtorsFunc(Fn, CXXGlobalDtors);
383 /// Emit the code necessary to initialize the given global variable.
384 void CodeGenFunction::GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn,
386 llvm::GlobalVariable *Addr,
388 // Check if we need to emit debug info for variable initializer.
389 if (!D->hasAttr<NoDebugAttr>())
390 maybeInitializeDebugInfo();
392 StartFunction(GlobalDecl(D), getContext().VoidTy, Fn,
393 getTypes().arrangeNullaryFunction(),
394 FunctionArgList(), D->getInit()->getExprLoc());
396 // Use guarded initialization if the global variable is weak. This
397 // occurs for, e.g., instantiated static data members and
398 // definitions explicitly marked weak.
399 if (Addr->getLinkage() == llvm::GlobalValue::WeakODRLinkage ||
400 Addr->getLinkage() == llvm::GlobalValue::WeakAnyLinkage) {
401 EmitCXXGuardedInit(*D, Addr, PerformInit);
403 EmitCXXGlobalVarDeclInit(*D, Addr, PerformInit);
410 CodeGenFunction::GenerateCXXGlobalInitFunc(llvm::Function *Fn,
411 ArrayRef<llvm::Constant *> Decls,
412 llvm::GlobalVariable *Guard) {
413 // Initialize debug info if needed.
414 maybeInitializeDebugInfo();
416 StartFunction(GlobalDecl(), getContext().VoidTy, Fn,
417 getTypes().arrangeNullaryFunction(),
418 FunctionArgList(), SourceLocation());
420 llvm::BasicBlock *ExitBlock = 0;
422 // If we have a guard variable, check whether we've already performed these
423 // initializations. This happens for TLS initialization functions.
424 llvm::Value *GuardVal = Builder.CreateLoad(Guard);
425 llvm::Value *Uninit = Builder.CreateIsNull(GuardVal, "guard.uninitialized");
426 // Mark as initialized before initializing anything else. If the
427 // initializers use previously-initialized thread_local vars, that's
428 // probably supposed to be OK, but the standard doesn't say.
429 Builder.CreateStore(llvm::ConstantInt::get(GuardVal->getType(), 1), Guard);
430 llvm::BasicBlock *InitBlock = createBasicBlock("init");
431 ExitBlock = createBasicBlock("exit");
432 Builder.CreateCondBr(Uninit, InitBlock, ExitBlock);
433 EmitBlock(InitBlock);
436 RunCleanupsScope Scope(*this);
438 // When building in Objective-C++ ARC mode, create an autorelease pool
439 // around the global initializers.
440 if (getLangOpts().ObjCAutoRefCount && getLangOpts().CPlusPlus) {
441 llvm::Value *token = EmitObjCAutoreleasePoolPush();
442 EmitObjCAutoreleasePoolCleanup(token);
445 for (unsigned i = 0, e = Decls.size(); i != e; ++i)
447 EmitRuntimeCall(Decls[i]);
449 Scope.ForceCleanup();
452 Builder.CreateBr(ExitBlock);
453 EmitBlock(ExitBlock);
459 void CodeGenFunction::GenerateCXXGlobalDtorsFunc(llvm::Function *Fn,
460 const std::vector<std::pair<llvm::WeakVH, llvm::Constant*> >
462 // Initialize debug info if needed.
463 maybeInitializeDebugInfo();
465 StartFunction(GlobalDecl(), getContext().VoidTy, Fn,
466 getTypes().arrangeNullaryFunction(),
467 FunctionArgList(), SourceLocation());
469 // Emit the dtors, in reverse order from construction.
470 for (unsigned i = 0, e = DtorsAndObjects.size(); i != e; ++i) {
471 llvm::Value *Callee = DtorsAndObjects[e - i - 1].first;
472 llvm::CallInst *CI = Builder.CreateCall(Callee,
473 DtorsAndObjects[e - i - 1].second);
474 // Make sure the call and the callee agree on calling convention.
475 if (llvm::Function *F = dyn_cast<llvm::Function>(Callee))
476 CI->setCallingConv(F->getCallingConv());
482 /// generateDestroyHelper - Generates a helper function which, when
483 /// invoked, destroys the given object.
485 CodeGenFunction::generateDestroyHelper(llvm::Constant *addr,
487 Destroyer *destroyer,
488 bool useEHCleanupForArray) {
489 FunctionArgList args;
490 ImplicitParamDecl dst(0, SourceLocation(), 0, getContext().VoidPtrTy);
491 args.push_back(&dst);
493 const CGFunctionInfo &FI =
494 CGM.getTypes().arrangeFunctionDeclaration(getContext().VoidTy, args,
495 FunctionType::ExtInfo(),
497 llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI);
499 CreateGlobalInitOrDestructFunction(CGM, FTy, "__cxx_global_array_dtor");
501 // Initialize debug info if needed.
502 maybeInitializeDebugInfo();
504 StartFunction(GlobalDecl(), getContext().VoidTy, fn, FI, args,
507 emitDestroy(addr, type, destroyer, useEHCleanupForArray);