CGDeclCXX.cpp revision 88d117c2eedd7c5bec57ac983a98d5e12bdd2cc6
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 std::vector<const llvm::Type *> Params; 121 Params.push_back(Int8PtrTy); 122 123 // Get the destructor function type 124 const llvm::Type *DtorFnTy = 125 llvm::FunctionType::get(llvm::Type::getVoidTy(getLLVMContext()), 126 Params, false); 127 DtorFnTy = llvm::PointerType::getUnqual(DtorFnTy); 128 129 Params.clear(); 130 Params.push_back(DtorFnTy); 131 Params.push_back(Int8PtrTy); 132 Params.push_back(Int8PtrTy); 133 134 // Get the __cxa_atexit function type 135 // extern "C" int __cxa_atexit ( void (*f)(void *), void *p, void *d ); 136 const llvm::FunctionType *AtExitFnTy = 137 llvm::FunctionType::get(ConvertType(getContext().IntTy), Params, false); 138 139 llvm::Constant *AtExitFn = CGM.CreateRuntimeFunction(AtExitFnTy, 140 "__cxa_atexit"); 141 142 llvm::Constant *Handle = CGM.CreateRuntimeVariable(Int8PtrTy, 143 "__dso_handle"); 144 llvm::Value *Args[3] = { llvm::ConstantExpr::getBitCast(DtorFn, DtorFnTy), 145 llvm::ConstantExpr::getBitCast(DeclPtr, Int8PtrTy), 146 llvm::ConstantExpr::getBitCast(Handle, Int8PtrTy) }; 147 Builder.CreateCall(AtExitFn, &Args[0], llvm::array_endof(Args)); 148} 149 150void CodeGenFunction::EmitCXXGuardedInit(const VarDecl &D, 151 llvm::GlobalVariable *DeclPtr) { 152 CGM.getCXXABI().EmitGuardedInit(*this, D, DeclPtr); 153} 154 155static llvm::Function * 156CreateGlobalInitOrDestructFunction(CodeGenModule &CGM, 157 const llvm::FunctionType *FTy, 158 llvm::StringRef Name) { 159 llvm::Function *Fn = 160 llvm::Function::Create(FTy, llvm::GlobalValue::InternalLinkage, 161 Name, &CGM.getModule()); 162 if (!CGM.getContext().getLangOptions().AppleKext) { 163 // Set the section if needed. 164 if (const char *Section = 165 CGM.getContext().Target.getStaticInitSectionSpecifier()) 166 Fn->setSection(Section); 167 } 168 169 if (!CGM.getLangOptions().Exceptions) 170 Fn->setDoesNotThrow(); 171 172 return Fn; 173} 174 175void 176CodeGenModule::EmitCXXGlobalVarDeclInitFunc(const VarDecl *D, 177 llvm::GlobalVariable *Addr) { 178 const llvm::FunctionType *FTy 179 = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), 180 false); 181 182 // Create a variable initialization function. 183 llvm::Function *Fn = 184 CreateGlobalInitOrDestructFunction(*this, FTy, "__cxx_global_var_init"); 185 186 CodeGenFunction(*this).GenerateCXXGlobalVarDeclInitFunc(Fn, D, Addr); 187 188 if (D->hasAttr<InitPriorityAttr>()) { 189 unsigned int order = D->getAttr<InitPriorityAttr>()->getPriority(); 190 OrderGlobalInits Key(order, PrioritizedCXXGlobalInits.size()); 191 PrioritizedCXXGlobalInits.push_back(std::make_pair(Key, Fn)); 192 DelayedCXXInitPosition.erase(D); 193 } 194 else { 195 llvm::DenseMap<const Decl *, unsigned>::iterator I = 196 DelayedCXXInitPosition.find(D); 197 if (I == DelayedCXXInitPosition.end()) { 198 CXXGlobalInits.push_back(Fn); 199 } else { 200 assert(CXXGlobalInits[I->second] == 0); 201 CXXGlobalInits[I->second] = Fn; 202 DelayedCXXInitPosition.erase(I); 203 } 204 } 205} 206 207void 208CodeGenModule::EmitCXXGlobalInitFunc() { 209 while (!CXXGlobalInits.empty() && !CXXGlobalInits.back()) 210 CXXGlobalInits.pop_back(); 211 212 if (CXXGlobalInits.empty() && PrioritizedCXXGlobalInits.empty()) 213 return; 214 215 const llvm::FunctionType *FTy 216 = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), 217 false); 218 219 // Create our global initialization function. 220 llvm::Function *Fn = 221 CreateGlobalInitOrDestructFunction(*this, FTy, "_GLOBAL__I_a"); 222 223 if (!PrioritizedCXXGlobalInits.empty()) { 224 llvm::SmallVector<llvm::Constant*, 8> LocalCXXGlobalInits; 225 llvm::array_pod_sort(PrioritizedCXXGlobalInits.begin(), 226 PrioritizedCXXGlobalInits.end()); 227 for (unsigned i = 0; i < PrioritizedCXXGlobalInits.size(); i++) { 228 llvm::Function *Fn = PrioritizedCXXGlobalInits[i].second; 229 LocalCXXGlobalInits.push_back(Fn); 230 } 231 LocalCXXGlobalInits.append(CXXGlobalInits.begin(), CXXGlobalInits.end()); 232 CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, 233 &LocalCXXGlobalInits[0], 234 LocalCXXGlobalInits.size()); 235 } 236 else 237 CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, 238 &CXXGlobalInits[0], 239 CXXGlobalInits.size()); 240 AddGlobalCtor(Fn); 241} 242 243void CodeGenModule::EmitCXXGlobalDtorFunc() { 244 if (CXXGlobalDtors.empty()) 245 return; 246 247 const llvm::FunctionType *FTy 248 = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), 249 false); 250 251 // Create our global destructor function. 252 llvm::Function *Fn = 253 CreateGlobalInitOrDestructFunction(*this, FTy, "_GLOBAL__D_a"); 254 255 CodeGenFunction(*this).GenerateCXXGlobalDtorFunc(Fn, CXXGlobalDtors); 256 AddGlobalDtor(Fn); 257} 258 259/// Emit the code necessary to initialize the given global variable. 260void CodeGenFunction::GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn, 261 const VarDecl *D, 262 llvm::GlobalVariable *Addr) { 263 StartFunction(GlobalDecl(), getContext().VoidTy, Fn, FunctionArgList(), 264 SourceLocation(), CC_Default); 265 266 // Use guarded initialization if the global variable is weak due to 267 // being a class template's static data member. 268 if (Addr->hasWeakLinkage() && D->getInstantiatedFromStaticDataMember()) { 269 EmitCXXGuardedInit(*D, Addr); 270 } else { 271 EmitCXXGlobalVarDeclInit(*D, Addr); 272 } 273 274 FinishFunction(); 275} 276 277void CodeGenFunction::GenerateCXXGlobalInitFunc(llvm::Function *Fn, 278 llvm::Constant **Decls, 279 unsigned NumDecls) { 280 StartFunction(GlobalDecl(), getContext().VoidTy, Fn, FunctionArgList(), 281 SourceLocation(), CC_Default); 282 283 for (unsigned i = 0; i != NumDecls; ++i) 284 if (Decls[i]) 285 Builder.CreateCall(Decls[i]); 286 287 FinishFunction(); 288} 289 290void CodeGenFunction::GenerateCXXGlobalDtorFunc(llvm::Function *Fn, 291 const std::vector<std::pair<llvm::WeakVH, llvm::Constant*> > 292 &DtorsAndObjects) { 293 const bool IsWin64 = getContext().Target.isWin64(); 294 295 StartFunction(GlobalDecl(), getContext().VoidTy, Fn, FunctionArgList(), 296 SourceLocation(), IsWin64 ? CC_Win64ThisCall : CC_Default); 297 298 // Emit the dtors, in reverse order from construction. 299 for (unsigned i = 0, e = DtorsAndObjects.size(); i != e; ++i) { 300 llvm::Value *Callee = DtorsAndObjects[e - i - 1].first; 301 llvm::CallInst *CI = Builder.CreateCall(Callee, 302 DtorsAndObjects[e - i - 1].second); 303 // Make sure the call and the callee agree on calling convention. 304 if (llvm::Function *F = dyn_cast<llvm::Function>(Callee)) 305 CI->setCallingConv(F->getCallingConv()); 306 } 307 308 FinishFunction(); 309} 310 311/// GenerateCXXAggrDestructorHelper - Generates a helper function which when 312/// invoked, calls the default destructor on array elements in reverse order of 313/// construction. 314llvm::Function * 315CodeGenFunction::GenerateCXXAggrDestructorHelper(const CXXDestructorDecl *D, 316 const ArrayType *Array, 317 llvm::Value *This) { 318 FunctionArgList Args; 319 ImplicitParamDecl *Dst = 320 ImplicitParamDecl::Create(getContext(), 0, 321 SourceLocation(), 0, 322 getContext().getPointerType(getContext().VoidTy)); 323 Args.push_back(std::make_pair(Dst, Dst->getType())); 324 325 const CGFunctionInfo &FI = 326 CGM.getTypes().getFunctionInfo(getContext().VoidTy, Args, 327 FunctionType::ExtInfo()); 328 const llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI, false); 329 llvm::Function *Fn = 330 CreateGlobalInitOrDestructFunction(CGM, FTy, "__cxx_global_array_dtor"); 331 332 StartFunction(GlobalDecl(), getContext().VoidTy, Fn, Args, SourceLocation(), 333 CC_Default); 334 335 QualType BaseElementTy = getContext().getBaseElementType(Array); 336 const llvm::Type *BasePtr = ConvertType(BaseElementTy)->getPointerTo(); 337 llvm::Value *BaseAddrPtr = Builder.CreateBitCast(This, BasePtr); 338 339 EmitCXXAggrDestructorCall(D, Array, BaseAddrPtr); 340 341 FinishFunction(); 342 343 return Fn; 344} 345