contrib/llvm/tools/clang/lib/CodeGen/CGDeclCXX.cpp

   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
  20 using namespace clang;
  21 using namespace CodeGen;
  22
  23 static 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   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)) {
  37     CodeGenModule &CGM = CGF.CGM;
  38     if (lv.isObjCStrong())
  39       CGM.getObjCRuntime().EmitObjCGlobalAssign(CGF, CGF.EmitScalarExpr(Init),
  40                                                 DeclPtr, D.isThreadSpecified());
  41     else if (lv.isObjCWeak())
  42       CGM.getObjCRuntime().EmitObjCWeakAssign(CGF, CGF.EmitScalarExpr(Init),
  43                                               DeclPtr);
  44     else
  45       CGF.EmitScalarInit(Init, &D, lv, false);
  46   } else if (type->isAnyComplexType()) {
  47     CGF.EmitComplexExprIntoAddr(Init, DeclPtr, lv.isVolatile());
  48   } else {
  49     CGF.EmitAggExpr(Init, AggValueSlot::forLValue(lv, true));
  50   }
  51 }
  52
  53 /// Emit code to cause the destruction of the given variable with
  54 /// static storage duration.
  55 static void EmitDeclDestroy(CodeGenFunction &CGF, const VarDecl &D,
  56                             llvm::Constant *addr) {
  57   CodeGenModule &CGM = CGF.CGM;
  58
  59   // FIXME:  __attribute__((cleanup)) ?
  60
  61   QualType type = D.getType();
  62   QualType::DestructionKind dtorKind = type.isDestructedType();
  63
  64   switch (dtorKind) {
  65   case QualType::DK_none:
  66     return;
  67
  68   case QualType::DK_cxx_destructor:
  69     break;
  70
  71   case QualType::DK_objc_strong_lifetime:
  72   case QualType::DK_objc_weak_lifetime:
  73     // We don't care about releasing objects during process teardown.
  74     return;
  75   }
  76
  77   llvm::Constant *function;
  78   llvm::Constant *argument;
  79
  80   // Special-case non-array C++ destructors, where there's a function
  81   // with the right signature that we can just call.
  82   const CXXRecordDecl *record = 0;
  83   if (dtorKind == QualType::DK_cxx_destructor &&
  84       (record = type->getAsCXXRecordDecl())) {
  85     assert(!record->hasTrivialDestructor());
  86     CXXDestructorDecl *dtor = record->getDestructor();
  87
  88     function = CGM.GetAddrOfCXXDestructor(dtor, Dtor_Complete);
  89     argument = addr;
  90
  91   // Otherwise, the standard logic requires a helper function.
  92   } else {
  93     function = CodeGenFunction(CGM).generateDestroyHelper(addr, type,
  94                                                   CGF.getDestroyer(dtorKind),
  95                                                   CGF.needsEHCleanup(dtorKind));
  96     argument = llvm::Constant::getNullValue(CGF.Int8PtrTy);
  97   }
  98
  99   CGF.EmitCXXGlobalDtorRegistration(function, argument);
 100 }
 101
 102 void CodeGenFunction::EmitCXXGlobalVarDeclInit(const VarDecl &D,
 103                                                llvm::Constant *DeclPtr) {
 104
 105   const Expr *Init = D.getInit();
 106   QualType T = D.getType();
 107
 108   if (!T->isReferenceType()) {
 109     EmitDeclInit(*this, D, DeclPtr);
 110     EmitDeclDestroy(*this, D, DeclPtr);
 111     return;
 112   }
 113
 114   unsigned Alignment = getContext().getDeclAlign(&D).getQuantity();
 115   RValue RV = EmitReferenceBindingToExpr(Init, &D);
 116   EmitStoreOfScalar(RV.getScalarVal(), DeclPtr, false, Alignment, T);
 117 }
 118
 119 void
 120 CodeGenFunction::EmitCXXGlobalDtorRegistration(llvm::Constant *DtorFn,
 121                                                llvm::Constant *DeclPtr) {
 122   // Generate a global destructor entry if not using __cxa_atexit.
 123   if (!CGM.getCodeGenOpts().CXAAtExit) {
 124     CGM.AddCXXDtorEntry(DtorFn, DeclPtr);
 125     return;
 126   }
 127
 128   // Get the destructor function type
 129   llvm::Type *ArgTys[] = { Int8PtrTy };
 130   llvm::Type *DtorFnTy =
 131     llvm::FunctionType::get(llvm::Type::getVoidTy(getLLVMContext()),
 132                             ArgTys, false);
 133   DtorFnTy = llvm::PointerType::getUnqual(DtorFnTy);
 134
 135   llvm::Type *Params[] = { DtorFnTy, Int8PtrTy, Int8PtrTy };
 136
 137   // Get the __cxa_atexit function type
 138   // extern "C" int __cxa_atexit ( void (*f)(void *), void *p, void *d );
 139   const llvm::FunctionType *AtExitFnTy =
 140     llvm::FunctionType::get(ConvertType(getContext().IntTy), Params, false);
 141
 142   llvm::Constant *AtExitFn = CGM.CreateRuntimeFunction(AtExitFnTy,
 143                                                        "__cxa_atexit");
 144   if (llvm::Function *Fn = dyn_cast<llvm::Function>(AtExitFn))
 145     Fn->setDoesNotThrow();
 146
 147   llvm::Constant *Handle = CGM.CreateRuntimeVariable(Int8PtrTy,
 148                                                      "__dso_handle");
 149   llvm::Value *Args[3] = { llvm::ConstantExpr::getBitCast(DtorFn, DtorFnTy),
 150                            llvm::ConstantExpr::getBitCast(DeclPtr, Int8PtrTy),
 151                            llvm::ConstantExpr::getBitCast(Handle, Int8PtrTy) };
 152   Builder.CreateCall(AtExitFn, Args);
 153 }
 154
 155 void CodeGenFunction::EmitCXXGuardedInit(const VarDecl &D,
 156                                          llvm::GlobalVariable *DeclPtr) {
 157   // If we've been asked to forbid guard variables, emit an error now.
 158   // This diagnostic is hard-coded for Darwin's use case;  we can find
 159   // better phrasing if someone else needs it.
 160   if (CGM.getCodeGenOpts().ForbidGuardVariables)
 161     CGM.Error(D.getLocation(),
 162               "this initialization requires a guard variable, which "
 163               "the kernel does not support");
 164
 165   CGM.getCXXABI().EmitGuardedInit(*this, D, DeclPtr);
 166 }
 167
 168 static llvm::Function *
 169 CreateGlobalInitOrDestructFunction(CodeGenModule &CGM,
 170                                    const llvm::FunctionType *FTy,
 171                                    llvm::StringRef Name) {
 172   llvm::Function *Fn =
 173     llvm::Function::Create(FTy, llvm::GlobalValue::InternalLinkage,
 174                            Name, &CGM.getModule());
 175   if (!CGM.getContext().getLangOptions().AppleKext) {
 176     // Set the section if needed.
 177     if (const char *Section =
 178           CGM.getContext().Target.getStaticInitSectionSpecifier())
 179       Fn->setSection(Section);
 180   }
 181
 182   if (!CGM.getLangOptions().Exceptions)
 183     Fn->setDoesNotThrow();
 184
 185   return Fn;
 186 }
 187
 188 void
 189 CodeGenModule::EmitCXXGlobalVarDeclInitFunc(const VarDecl *D,
 190                                             llvm::GlobalVariable *Addr) {
 191   const llvm::FunctionType *FTy
 192     = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
 193                               false);
 194
 195   // Create a variable initialization function.
 196   llvm::Function *Fn =
 197     CreateGlobalInitOrDestructFunction(*this, FTy, "__cxx_global_var_init");
 198
 199   CodeGenFunction(*this).GenerateCXXGlobalVarDeclInitFunc(Fn, D, Addr);
 200
 201   if (D->hasAttr<InitPriorityAttr>()) {
 202     unsigned int order = D->getAttr<InitPriorityAttr>()->getPriority();
 203     OrderGlobalInits Key(order, PrioritizedCXXGlobalInits.size());
 204     PrioritizedCXXGlobalInits.push_back(std::make_pair(Key, Fn));
 205     DelayedCXXInitPosition.erase(D);
 206   }
 207   else {
 208     llvm::DenseMap<const Decl *, unsigned>::iterator I =
 209       DelayedCXXInitPosition.find(D);
 210     if (I == DelayedCXXInitPosition.end()) {
 211       CXXGlobalInits.push_back(Fn);
 212     } else {
 213       assert(CXXGlobalInits[I->second] == 0);
 214       CXXGlobalInits[I->second] = Fn;
 215       DelayedCXXInitPosition.erase(I);
 216     }
 217   }
 218 }
 219
 220 void
 221 CodeGenModule::EmitCXXGlobalInitFunc() {
 222   while (!CXXGlobalInits.empty() && !CXXGlobalInits.back())
 223     CXXGlobalInits.pop_back();
 224
 225   if (CXXGlobalInits.empty() && PrioritizedCXXGlobalInits.empty())
 226     return;
 227
 228   const llvm::FunctionType *FTy
 229     = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
 230                               false);
 231
 232   // Create our global initialization function.
 233   llvm::Function *Fn =
 234     CreateGlobalInitOrDestructFunction(*this, FTy, "_GLOBAL__I_a");
 235
 236   if (!PrioritizedCXXGlobalInits.empty()) {
 237     llvm::SmallVector<llvm::Constant*, 8> LocalCXXGlobalInits;
 238     llvm::array_pod_sort(PrioritizedCXXGlobalInits.begin(),
 239                          PrioritizedCXXGlobalInits.end());
 240     for (unsigned i = 0; i < PrioritizedCXXGlobalInits.size(); i++) {
 241       llvm::Function *Fn = PrioritizedCXXGlobalInits[i].second;
 242       LocalCXXGlobalInits.push_back(Fn);
 243     }
 244     LocalCXXGlobalInits.append(CXXGlobalInits.begin(), CXXGlobalInits.end());
 245     CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn,
 246                                                     &LocalCXXGlobalInits[0],
 247                                                     LocalCXXGlobalInits.size());
 248   }
 249   else
 250     CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn,
 251                                                      &CXXGlobalInits[0],
 252                                                      CXXGlobalInits.size());
 253   AddGlobalCtor(Fn);
 254   CXXGlobalInits.clear();
 255   PrioritizedCXXGlobalInits.clear();
 256 }
 257
 258 void CodeGenModule::EmitCXXGlobalDtorFunc() {
 259   if (CXXGlobalDtors.empty())
 260     return;
 261
 262   const llvm::FunctionType *FTy
 263     = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
 264                               false);
 265
 266   // Create our global destructor function.
 267   llvm::Function *Fn =
 268     CreateGlobalInitOrDestructFunction(*this, FTy, "_GLOBAL__D_a");
 269
 270   CodeGenFunction(*this).GenerateCXXGlobalDtorFunc(Fn, CXXGlobalDtors);
 271   AddGlobalDtor(Fn);
 272 }
 273
 274 /// Emit the code necessary to initialize the given global variable.
 275 void CodeGenFunction::GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn,
 276                                                        const VarDecl *D,
 277                                                  llvm::GlobalVariable *Addr) {
 278   StartFunction(GlobalDecl(), getContext().VoidTy, Fn,
 279                 getTypes().getNullaryFunctionInfo(),
 280                 FunctionArgList(), SourceLocation());
 281
 282   // Use guarded initialization if the global variable is weak. This
 283   // occurs for, e.g., instantiated static data members and
 284   // definitions explicitly marked weak.
 285   if (Addr->getLinkage() == llvm::GlobalValue::WeakODRLinkage ||
 286       Addr->getLinkage() == llvm::GlobalValue::WeakAnyLinkage) {
 287     EmitCXXGuardedInit(*D, Addr);
 288   } else {
 289     EmitCXXGlobalVarDeclInit(*D, Addr);
 290   }
 291
 292   FinishFunction();
 293 }
 294
 295 void CodeGenFunction::GenerateCXXGlobalInitFunc(llvm::Function *Fn,
 296                                                 llvm::Constant **Decls,
 297                                                 unsigned NumDecls) {
 298   StartFunction(GlobalDecl(), getContext().VoidTy, Fn,
 299                 getTypes().getNullaryFunctionInfo(),
 300                 FunctionArgList(), SourceLocation());
 301
 302   RunCleanupsScope Scope(*this);
 303
 304   // When building in Objective-C++ ARC mode, create an autorelease pool
 305   // around the global initializers.
 306   if (getLangOptions().ObjCAutoRefCount && getLangOptions().CPlusPlus) {
 307     llvm::Value *token = EmitObjCAutoreleasePoolPush();
 308     EmitObjCAutoreleasePoolCleanup(token);
 309   }
 310
 311   for (unsigned i = 0; i != NumDecls; ++i)
 312     if (Decls[i])
 313       Builder.CreateCall(Decls[i]);
 314
 315   Scope.ForceCleanup();
 316
 317   FinishFunction();
 318 }
 319
 320 void CodeGenFunction::GenerateCXXGlobalDtorFunc(llvm::Function *Fn,
 321                   const std::vector<std::pair<llvm::WeakVH, llvm::Constant*> >
 322                                                 &DtorsAndObjects) {
 323   StartFunction(GlobalDecl(), getContext().VoidTy, Fn,
 324                 getTypes().getNullaryFunctionInfo(),
 325                 FunctionArgList(), SourceLocation());
 326
 327   // Emit the dtors, in reverse order from construction.
 328   for (unsigned i = 0, e = DtorsAndObjects.size(); i != e; ++i) {
 329     llvm::Value *Callee = DtorsAndObjects[e - i - 1].first;
 330     llvm::CallInst *CI = Builder.CreateCall(Callee,
 331                                             DtorsAndObjects[e - i - 1].second);
 332     // Make sure the call and the callee agree on calling convention.
 333     if (llvm::Function *F = dyn_cast<llvm::Function>(Callee))
 334       CI->setCallingConv(F->getCallingConv());
 335   }
 336
 337   FinishFunction();
 338 }
 339
 340 /// generateDestroyHelper - Generates a helper function which, when
 341 /// invoked, destroys the given object.
 342 llvm::Function *
 343 CodeGenFunction::generateDestroyHelper(llvm::Constant *addr,
 344                                        QualType type,
 345                                        Destroyer &destroyer,
 346                                        bool useEHCleanupForArray) {
 347   FunctionArgList args;
 348   ImplicitParamDecl dst(0, SourceLocation(), 0, getContext().VoidPtrTy);
 349   args.push_back(&dst);
 350
 351   const CGFunctionInfo &FI =
 352     CGM.getTypes().getFunctionInfo(getContext().VoidTy, args,
 353                                    FunctionType::ExtInfo());
 354   const llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI, false);
 355   llvm::Function *fn =
 356     CreateGlobalInitOrDestructFunction(CGM, FTy, "__cxx_global_array_dtor");
 357
 358   StartFunction(GlobalDecl(), getContext().VoidTy, fn, FI, args,
 359                 SourceLocation());
 360
 361   emitDestroy(addr, type, destroyer, useEHCleanupForArray);
 362
 363   FinishFunction();
 364
 365   return fn;
 366 }
 367