CGDeclCXX.cpp revision 223017
1//===--- 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" 15#include "CGObjCRuntime.h" 16#include "CGCXXABI.h" 17#include "clang/Frontend/CodeGenOptions.h" 18#include "llvm/Intrinsics.h" 19 20using namespace clang; 21using namespace CodeGen; 22 23static 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 29 ASTContext &Context = CGF.getContext(); 30 31 const Expr *Init = D.getInit(); 32 QualType T = D.getType(); 33 bool isVolatile = Context.getCanonicalType(T).isVolatileQualified(); 34 35 unsigned Alignment = Context.getDeclAlign(&D).getQuantity(); 36 if (!CGF.hasAggregateLLVMType(T)) { 37 llvm::Value *V = CGF.EmitScalarExpr(Init); 38 CodeGenModule &CGM = CGF.CGM; 39 Qualifiers::GC GCAttr = CGM.getContext().getObjCGCAttrKind(T); 40 if (GCAttr == Qualifiers::Strong) 41 CGM.getObjCRuntime().EmitObjCGlobalAssign(CGF, V, DeclPtr, 42 D.isThreadSpecified()); 43 else if (GCAttr == Qualifiers::Weak) 44 CGM.getObjCRuntime().EmitObjCWeakAssign(CGF, V, DeclPtr); 45 else 46 CGF.EmitStoreOfScalar(V, DeclPtr, isVolatile, Alignment, T); 47 } else if (T->isAnyComplexType()) { 48 CGF.EmitComplexExprIntoAddr(Init, DeclPtr, isVolatile); 49 } else { 50 CGF.EmitAggExpr(Init, AggValueSlot::forAddr(DeclPtr, isVolatile, true)); 51 } 52} 53 54/// Emit code to cause the destruction of the given variable with 55/// static storage duration. 56static void EmitDeclDestroy(CodeGenFunction &CGF, const VarDecl &D, 57 llvm::Constant *DeclPtr) { 58 CodeGenModule &CGM = CGF.CGM; 59 ASTContext &Context = CGF.getContext(); 60 61 QualType T = D.getType(); 62 63 // Drill down past array types. 64 const ConstantArrayType *Array = Context.getAsConstantArrayType(T); 65 if (Array) 66 T = Context.getBaseElementType(Array); 67 68 /// If that's not a record, we're done. 69 /// FIXME: __attribute__((cleanup)) ? 70 const RecordType *RT = T->getAs<RecordType>(); 71 if (!RT) 72 return; 73 74 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 75 if (RD->hasTrivialDestructor()) 76 return; 77 78 CXXDestructorDecl *Dtor = RD->getDestructor(); 79 80 llvm::Constant *DtorFn; 81 if (Array) { 82 DtorFn = 83 CodeGenFunction(CGM).GenerateCXXAggrDestructorHelper(Dtor, Array, 84 DeclPtr); 85 const llvm::Type *Int8PtrTy = 86 llvm::Type::getInt8PtrTy(CGM.getLLVMContext()); 87 DeclPtr = llvm::Constant::getNullValue(Int8PtrTy); 88 } else 89 DtorFn = CGM.GetAddrOfCXXDestructor(Dtor, Dtor_Complete); 90 91 CGF.EmitCXXGlobalDtorRegistration(DtorFn, DeclPtr); 92} 93 94void CodeGenFunction::EmitCXXGlobalVarDeclInit(const VarDecl &D, 95 llvm::Constant *DeclPtr) { 96 97 const Expr *Init = D.getInit(); 98 QualType T = D.getType(); 99 100 if (!T->isReferenceType()) { 101 EmitDeclInit(*this, D, DeclPtr); 102 EmitDeclDestroy(*this, D, DeclPtr); 103 return; 104 } 105 106 unsigned Alignment = getContext().getDeclAlign(&D).getQuantity(); 107 RValue RV = EmitReferenceBindingToExpr(Init, &D); 108 EmitStoreOfScalar(RV.getScalarVal(), DeclPtr, false, Alignment, T); 109} 110 111void 112CodeGenFunction::EmitCXXGlobalDtorRegistration(llvm::Constant *DtorFn, 113 llvm::Constant *DeclPtr) { 114 // Generate a global destructor entry if not using __cxa_atexit. 115 if (!CGM.getCodeGenOpts().CXAAtExit) { 116 CGM.AddCXXDtorEntry(DtorFn, DeclPtr); 117 return; 118 } 119 120 // Get the destructor function type 121 const llvm::Type *DtorFnTy = 122 llvm::FunctionType::get(llvm::Type::getVoidTy(getLLVMContext()), 123 Int8PtrTy, false); 124 DtorFnTy = llvm::PointerType::getUnqual(DtorFnTy); 125 126 const llvm::Type *Params[] = { DtorFnTy, Int8PtrTy, Int8PtrTy }; 127 128 // Get the __cxa_atexit function type 129 // extern "C" int __cxa_atexit ( void (*f)(void *), void *p, void *d ); 130 const llvm::FunctionType *AtExitFnTy = 131 llvm::FunctionType::get(ConvertType(getContext().IntTy), Params, false); 132 133 llvm::Constant *AtExitFn = CGM.CreateRuntimeFunction(AtExitFnTy, 134 "__cxa_atexit"); 135 if (llvm::Function *Fn = dyn_cast<llvm::Function>(AtExitFn)) 136 Fn->setDoesNotThrow(); 137 138 llvm::Constant *Handle = CGM.CreateRuntimeVariable(Int8PtrTy, 139 "__dso_handle"); 140 llvm::Value *Args[3] = { llvm::ConstantExpr::getBitCast(DtorFn, DtorFnTy), 141 llvm::ConstantExpr::getBitCast(DeclPtr, Int8PtrTy), 142 llvm::ConstantExpr::getBitCast(Handle, Int8PtrTy) }; 143 Builder.CreateCall(AtExitFn, &Args[0], llvm::array_endof(Args)); 144} 145 146void CodeGenFunction::EmitCXXGuardedInit(const VarDecl &D, 147 llvm::GlobalVariable *DeclPtr) { 148 // If we've been asked to forbid guard variables, emit an error now. 149 // This diagnostic is hard-coded for Darwin's use case; we can find 150 // better phrasing if someone else needs it. 151 if (CGM.getCodeGenOpts().ForbidGuardVariables) 152 CGM.Error(D.getLocation(), 153 "this initialization requires a guard variable, which " 154 "the kernel does not support"); 155 156 CGM.getCXXABI().EmitGuardedInit(*this, D, DeclPtr); 157} 158 159static llvm::Function * 160CreateGlobalInitOrDestructFunction(CodeGenModule &CGM, 161 const llvm::FunctionType *FTy, 162 llvm::StringRef Name) { 163 llvm::Function *Fn = 164 llvm::Function::Create(FTy, llvm::GlobalValue::InternalLinkage, 165 Name, &CGM.getModule()); 166 if (!CGM.getContext().getLangOptions().AppleKext) { 167 // Set the section if needed. 168 if (const char *Section = 169 CGM.getContext().Target.getStaticInitSectionSpecifier()) 170 Fn->setSection(Section); 171 } 172 173 if (!CGM.getLangOptions().Exceptions) 174 Fn->setDoesNotThrow(); 175 176 return Fn; 177} 178 179void 180CodeGenModule::EmitCXXGlobalVarDeclInitFunc(const VarDecl *D, 181 llvm::GlobalVariable *Addr) { 182 const llvm::FunctionType *FTy 183 = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), 184 false); 185 186 // Create a variable initialization function. 187 llvm::Function *Fn = 188 CreateGlobalInitOrDestructFunction(*this, FTy, "__cxx_global_var_init"); 189 190 CodeGenFunction(*this).GenerateCXXGlobalVarDeclInitFunc(Fn, D, Addr); 191 192 if (D->hasAttr<InitPriorityAttr>()) { 193 unsigned int order = D->getAttr<InitPriorityAttr>()->getPriority(); 194 OrderGlobalInits Key(order, PrioritizedCXXGlobalInits.size()); 195 PrioritizedCXXGlobalInits.push_back(std::make_pair(Key, Fn)); 196 DelayedCXXInitPosition.erase(D); 197 } 198 else { 199 llvm::DenseMap<const Decl *, unsigned>::iterator I = 200 DelayedCXXInitPosition.find(D); 201 if (I == DelayedCXXInitPosition.end()) { 202 CXXGlobalInits.push_back(Fn); 203 } else { 204 assert(CXXGlobalInits[I->second] == 0); 205 CXXGlobalInits[I->second] = Fn; 206 DelayedCXXInitPosition.erase(I); 207 } 208 } 209} 210 211void 212CodeGenModule::EmitCXXGlobalInitFunc() { 213 while (!CXXGlobalInits.empty() && !CXXGlobalInits.back()) 214 CXXGlobalInits.pop_back(); 215 216 if (CXXGlobalInits.empty() && PrioritizedCXXGlobalInits.empty()) 217 return; 218 219 const llvm::FunctionType *FTy 220 = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), 221 false); 222 223 // Create our global initialization function. 224 llvm::Function *Fn = 225 CreateGlobalInitOrDestructFunction(*this, FTy, "_GLOBAL__I_a"); 226 227 if (!PrioritizedCXXGlobalInits.empty()) { 228 llvm::SmallVector<llvm::Constant*, 8> LocalCXXGlobalInits; 229 llvm::array_pod_sort(PrioritizedCXXGlobalInits.begin(), 230 PrioritizedCXXGlobalInits.end()); 231 for (unsigned i = 0; i < PrioritizedCXXGlobalInits.size(); i++) { 232 llvm::Function *Fn = PrioritizedCXXGlobalInits[i].second; 233 LocalCXXGlobalInits.push_back(Fn); 234 } 235 LocalCXXGlobalInits.append(CXXGlobalInits.begin(), CXXGlobalInits.end()); 236 CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, 237 &LocalCXXGlobalInits[0], 238 LocalCXXGlobalInits.size()); 239 } 240 else 241 CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, 242 &CXXGlobalInits[0], 243 CXXGlobalInits.size()); 244 AddGlobalCtor(Fn); 245 CXXGlobalInits.clear(); 246 PrioritizedCXXGlobalInits.clear(); 247} 248 249void CodeGenModule::EmitCXXGlobalDtorFunc() { 250 if (CXXGlobalDtors.empty()) 251 return; 252 253 const llvm::FunctionType *FTy 254 = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), 255 false); 256 257 // Create our global destructor function. 258 llvm::Function *Fn = 259 CreateGlobalInitOrDestructFunction(*this, FTy, "_GLOBAL__D_a"); 260 261 CodeGenFunction(*this).GenerateCXXGlobalDtorFunc(Fn, CXXGlobalDtors); 262 AddGlobalDtor(Fn); 263} 264 265/// Emit the code necessary to initialize the given global variable. 266void CodeGenFunction::GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn, 267 const VarDecl *D, 268 llvm::GlobalVariable *Addr) { 269 StartFunction(GlobalDecl(), getContext().VoidTy, Fn, 270 getTypes().getNullaryFunctionInfo(), 271 FunctionArgList(), SourceLocation()); 272 273 // Use guarded initialization if the global variable is weak due to 274 // being a class template's static data member. These will always 275 // have weak_odr linkage. 276 if (Addr->getLinkage() == llvm::GlobalValue::WeakODRLinkage && 277 D->isStaticDataMember() && 278 D->getInstantiatedFromStaticDataMember()) { 279 EmitCXXGuardedInit(*D, Addr); 280 } else { 281 EmitCXXGlobalVarDeclInit(*D, Addr); 282 } 283 284 FinishFunction(); 285} 286 287void CodeGenFunction::GenerateCXXGlobalInitFunc(llvm::Function *Fn, 288 llvm::Constant **Decls, 289 unsigned NumDecls) { 290 StartFunction(GlobalDecl(), getContext().VoidTy, Fn, 291 getTypes().getNullaryFunctionInfo(), 292 FunctionArgList(), SourceLocation()); 293 294 for (unsigned i = 0; i != NumDecls; ++i) 295 if (Decls[i]) 296 Builder.CreateCall(Decls[i]); 297 298 FinishFunction(); 299} 300 301void CodeGenFunction::GenerateCXXGlobalDtorFunc(llvm::Function *Fn, 302 const std::vector<std::pair<llvm::WeakVH, llvm::Constant*> > 303 &DtorsAndObjects) { 304 StartFunction(GlobalDecl(), getContext().VoidTy, Fn, 305 getTypes().getNullaryFunctionInfo(), 306 FunctionArgList(), SourceLocation()); 307 308 // Emit the dtors, in reverse order from construction. 309 for (unsigned i = 0, e = DtorsAndObjects.size(); i != e; ++i) { 310 llvm::Value *Callee = DtorsAndObjects[e - i - 1].first; 311 llvm::CallInst *CI = Builder.CreateCall(Callee, 312 DtorsAndObjects[e - i - 1].second); 313 // Make sure the call and the callee agree on calling convention. 314 if (llvm::Function *F = dyn_cast<llvm::Function>(Callee)) 315 CI->setCallingConv(F->getCallingConv()); 316 } 317 318 FinishFunction(); 319} 320 321/// GenerateCXXAggrDestructorHelper - Generates a helper function which when 322/// invoked, calls the default destructor on array elements in reverse order of 323/// construction. 324llvm::Function * 325CodeGenFunction::GenerateCXXAggrDestructorHelper(const CXXDestructorDecl *D, 326 const ArrayType *Array, 327 llvm::Value *This) { 328 FunctionArgList args; 329 ImplicitParamDecl dst(0, SourceLocation(), 0, getContext().VoidPtrTy); 330 args.push_back(&dst); 331 332 const CGFunctionInfo &FI = 333 CGM.getTypes().getFunctionInfo(getContext().VoidTy, args, 334 FunctionType::ExtInfo()); 335 const llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI, false); 336 llvm::Function *Fn = 337 CreateGlobalInitOrDestructFunction(CGM, FTy, "__cxx_global_array_dtor"); 338 339 StartFunction(GlobalDecl(), getContext().VoidTy, Fn, FI, args, 340 SourceLocation()); 341 342 QualType BaseElementTy = getContext().getBaseElementType(Array); 343 const llvm::Type *BasePtr = ConvertType(BaseElementTy)->getPointerTo(); 344 llvm::Value *BaseAddrPtr = Builder.CreateBitCast(This, BasePtr); 345 346 EmitCXXAggrDestructorCall(D, Array, BaseAddrPtr); 347 348 FinishFunction(); 349 350 return Fn; 351} 352