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

   1 //===--- CGVTables.cpp - Emit LLVM Code for C++ vtables -------------------===//
   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 C++ code generation of virtual tables.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "CodeGenFunction.h"
  15 #include "CGCXXABI.h"
  16 #include "CodeGenModule.h"
  17 #include "clang/AST/CXXInheritance.h"
  18 #include "clang/AST/RecordLayout.h"
  19 #include "clang/Frontend/CodeGenOptions.h"
  20 #include "llvm/ADT/DenseSet.h"
  21 #include "llvm/ADT/SetVector.h"
  22 #include "llvm/Support/Compiler.h"
  23 #include "llvm/Support/Format.h"
  24 #include "llvm/Transforms/Utils/Cloning.h"
  25 #include <algorithm>
  26 #include <cstdio>
  27
  28 using namespace clang;
  29 using namespace CodeGen;
  30
  31 CodeGenVTables::CodeGenVTables(CodeGenModule &CGM)
  32   : CGM(CGM), VTContext(CGM.getContext()) { }
  33
  34 llvm::Constant *CodeGenModule::GetAddrOfThunk(GlobalDecl GD,
  35                                               const ThunkInfo &Thunk) {
  36   const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
  37
  38   // Compute the mangled name.
  39   SmallString<256> Name;
  40   llvm::raw_svector_ostream Out(Name);
  41   if (const CXXDestructorDecl* DD = dyn_cast<CXXDestructorDecl>(MD))
  42     getCXXABI().getMangleContext().mangleCXXDtorThunk(DD, GD.getDtorType(),
  43                                                       Thunk.This, Out);
  44   else
  45     getCXXABI().getMangleContext().mangleThunk(MD, Thunk, Out);
  46   Out.flush();
  47
  48   llvm::Type *Ty = getTypes().GetFunctionTypeForVTable(GD);
  49   return GetOrCreateLLVMFunction(Name, Ty, GD, /*ForVTable=*/true);
  50 }
  51
  52 static llvm::Value *PerformTypeAdjustment(CodeGenFunction &CGF,
  53                                           llvm::Value *Ptr,
  54                                           int64_t NonVirtualAdjustment,
  55                                           int64_t VirtualAdjustment,
  56                                           bool IsReturnAdjustment) {
  57   if (!NonVirtualAdjustment && !VirtualAdjustment)
  58     return Ptr;
  59
  60   llvm::Type *Int8PtrTy = CGF.Int8PtrTy;
  61   llvm::Value *V = CGF.Builder.CreateBitCast(Ptr, Int8PtrTy);
  62
  63   if (NonVirtualAdjustment && !IsReturnAdjustment) {
  64     // Perform the non-virtual adjustment for a base-to-derived cast.
  65     V = CGF.Builder.CreateConstInBoundsGEP1_64(V, NonVirtualAdjustment);
  66   }
  67
  68   if (VirtualAdjustment) {
  69     llvm::Type *PtrDiffTy =
  70       CGF.ConvertType(CGF.getContext().getPointerDiffType());
  71
  72     // Perform the virtual adjustment.
  73     llvm::Value *VTablePtrPtr =
  74       CGF.Builder.CreateBitCast(V, Int8PtrTy->getPointerTo());
  75
  76     llvm::Value *VTablePtr = CGF.Builder.CreateLoad(VTablePtrPtr);
  77
  78     llvm::Value *OffsetPtr =
  79       CGF.Builder.CreateConstInBoundsGEP1_64(VTablePtr, VirtualAdjustment);
  80
  81     OffsetPtr = CGF.Builder.CreateBitCast(OffsetPtr, PtrDiffTy->getPointerTo());
  82
  83     // Load the adjustment offset from the vtable.
  84     llvm::Value *Offset = CGF.Builder.CreateLoad(OffsetPtr);
  85
  86     // Adjust our pointer.
  87     V = CGF.Builder.CreateInBoundsGEP(V, Offset);
  88   }
  89
  90   if (NonVirtualAdjustment && IsReturnAdjustment) {
  91     // Perform the non-virtual adjustment for a derived-to-base cast.
  92     V = CGF.Builder.CreateConstInBoundsGEP1_64(V, NonVirtualAdjustment);
  93   }
  94
  95   // Cast back to the original type.
  96   return CGF.Builder.CreateBitCast(V, Ptr->getType());
  97 }
  98
  99 static void setThunkVisibility(CodeGenModule &CGM, const CXXMethodDecl *MD,
 100                                const ThunkInfo &Thunk, llvm::Function *Fn) {
 101   CGM.setGlobalVisibility(Fn, MD);
 102
 103   if (!CGM.getCodeGenOpts().HiddenWeakVTables)
 104     return;
 105
 106   // If the thunk has weak/linkonce linkage, but the function must be
 107   // emitted in every translation unit that references it, then we can
 108   // emit its thunks with hidden visibility, since its thunks must be
 109   // emitted when the function is.
 110
 111   // This follows CodeGenModule::setTypeVisibility; see the comments
 112   // there for explanation.
 113
 114   if ((Fn->getLinkage() != llvm::GlobalVariable::LinkOnceODRLinkage &&
 115        Fn->getLinkage() != llvm::GlobalVariable::WeakODRLinkage) ||
 116       Fn->getVisibility() != llvm::GlobalVariable::DefaultVisibility)
 117     return;
 118
 119   if (MD->getExplicitVisibility(ValueDecl::VisibilityForValue))
 120     return;
 121
 122   switch (MD->getTemplateSpecializationKind()) {
 123   case TSK_ExplicitInstantiationDefinition:
 124   case TSK_ExplicitInstantiationDeclaration:
 125     return;
 126
 127   case TSK_Undeclared:
 128     break;
 129
 130   case TSK_ExplicitSpecialization:
 131   case TSK_ImplicitInstantiation:
 132     return;
 133     break;
 134   }
 135
 136   // If there's an explicit definition, and that definition is
 137   // out-of-line, then we can't assume that all users will have a
 138   // definition to emit.
 139   const FunctionDecl *Def = 0;
 140   if (MD->hasBody(Def) && Def->isOutOfLine())
 141     return;
 142
 143   Fn->setVisibility(llvm::GlobalValue::HiddenVisibility);
 144 }
 145
 146 #ifndef NDEBUG
 147 static bool similar(const ABIArgInfo &infoL, CanQualType typeL,
 148                     const ABIArgInfo &infoR, CanQualType typeR) {
 149   return (infoL.getKind() == infoR.getKind() &&
 150           (typeL == typeR ||
 151            (isa<PointerType>(typeL) && isa<PointerType>(typeR)) ||
 152            (isa<ReferenceType>(typeL) && isa<ReferenceType>(typeR))));
 153 }
 154 #endif
 155
 156 static RValue PerformReturnAdjustment(CodeGenFunction &CGF,
 157                                       QualType ResultType, RValue RV,
 158                                       const ThunkInfo &Thunk) {
 159   // Emit the return adjustment.
 160   bool NullCheckValue = !ResultType->isReferenceType();
 161
 162   llvm::BasicBlock *AdjustNull = 0;
 163   llvm::BasicBlock *AdjustNotNull = 0;
 164   llvm::BasicBlock *AdjustEnd = 0;
 165
 166   llvm::Value *ReturnValue = RV.getScalarVal();
 167
 168   if (NullCheckValue) {
 169     AdjustNull = CGF.createBasicBlock("adjust.null");
 170     AdjustNotNull = CGF.createBasicBlock("adjust.notnull");
 171     AdjustEnd = CGF.createBasicBlock("adjust.end");
 172
 173     llvm::Value *IsNull = CGF.Builder.CreateIsNull(ReturnValue);
 174     CGF.Builder.CreateCondBr(IsNull, AdjustNull, AdjustNotNull);
 175     CGF.EmitBlock(AdjustNotNull);
 176   }
 177
 178   ReturnValue = PerformTypeAdjustment(CGF, ReturnValue,
 179                                       Thunk.Return.NonVirtual,
 180                                       Thunk.Return.VBaseOffsetOffset,
 181                                       /*IsReturnAdjustment*/true);
 182
 183   if (NullCheckValue) {
 184     CGF.Builder.CreateBr(AdjustEnd);
 185     CGF.EmitBlock(AdjustNull);
 186     CGF.Builder.CreateBr(AdjustEnd);
 187     CGF.EmitBlock(AdjustEnd);
 188
 189     llvm::PHINode *PHI = CGF.Builder.CreatePHI(ReturnValue->getType(), 2);
 190     PHI->addIncoming(ReturnValue, AdjustNotNull);
 191     PHI->addIncoming(llvm::Constant::getNullValue(ReturnValue->getType()),
 192                      AdjustNull);
 193     ReturnValue = PHI;
 194   }
 195
 196   return RValue::get(ReturnValue);
 197 }
 198
 199 // This function does roughly the same thing as GenerateThunk, but in a
 200 // very different way, so that va_start and va_end work correctly.
 201 // FIXME: This function assumes "this" is the first non-sret LLVM argument of
 202 //        a function, and that there is an alloca built in the entry block
 203 //        for all accesses to "this".
 204 // FIXME: This function assumes there is only one "ret" statement per function.
 205 // FIXME: Cloning isn't correct in the presence of indirect goto!
 206 // FIXME: This implementation of thunks bloats codesize by duplicating the
 207 //        function definition.  There are alternatives:
 208 //        1. Add some sort of stub support to LLVM for cases where we can
 209 //           do a this adjustment, then a sibcall.
 210 //        2. We could transform the definition to take a va_list instead of an
 211 //           actual variable argument list, then have the thunks (including a
 212 //           no-op thunk for the regular definition) call va_start/va_end.
 213 //           There's a bit of per-call overhead for this solution, but it's
 214 //           better for codesize if the definition is long.
 215 void CodeGenFunction::GenerateVarArgsThunk(
 216                                       llvm::Function *Fn,
 217                                       const CGFunctionInfo &FnInfo,
 218                                       GlobalDecl GD, const ThunkInfo &Thunk) {
 219   const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
 220   const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
 221   QualType ResultType = FPT->getResultType();
 222
 223   // Get the original function
 224   assert(FnInfo.isVariadic());
 225   llvm::Type *Ty = CGM.getTypes().GetFunctionType(FnInfo);
 226   llvm::Value *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true);
 227   llvm::Function *BaseFn = cast<llvm::Function>(Callee);
 228
 229   // Clone to thunk.
 230   llvm::ValueToValueMapTy VMap;
 231   llvm::Function *NewFn = llvm::CloneFunction(BaseFn, VMap,
 232                                               /*ModuleLevelChanges=*/false);
 233   CGM.getModule().getFunctionList().push_back(NewFn);
 234   Fn->replaceAllUsesWith(NewFn);
 235   NewFn->takeName(Fn);
 236   Fn->eraseFromParent();
 237   Fn = NewFn;
 238
 239   // "Initialize" CGF (minimally).
 240   CurFn = Fn;
 241
 242   // Get the "this" value
 243   llvm::Function::arg_iterator AI = Fn->arg_begin();
 244   if (CGM.ReturnTypeUsesSRet(FnInfo))
 245     ++AI;
 246
 247   // Find the first store of "this", which will be to the alloca associated
 248   // with "this".
 249   llvm::Value *ThisPtr = &*AI;
 250   llvm::BasicBlock *EntryBB = Fn->begin();
 251   llvm::Instruction *ThisStore = 0;
 252   for (llvm::BasicBlock::iterator I = EntryBB->begin(), E = EntryBB->end();
 253        I != E; I++) {
 254     if (isa<llvm::StoreInst>(I) && I->getOperand(0) == ThisPtr) {
 255       ThisStore = cast<llvm::StoreInst>(I);
 256       break;
 257     }
 258   }
 259   assert(ThisStore && "Store of this should be in entry block?");
 260   // Adjust "this", if necessary.
 261   Builder.SetInsertPoint(ThisStore);
 262   llvm::Value *AdjustedThisPtr =
 263     PerformTypeAdjustment(*this, ThisPtr,
 264                           Thunk.This.NonVirtual,
 265                           Thunk.This.VCallOffsetOffset,
 266                           /*IsReturnAdjustment*/false);
 267   ThisStore->setOperand(0, AdjustedThisPtr);
 268
 269   if (!Thunk.Return.isEmpty()) {
 270     // Fix up the returned value, if necessary.
 271     for (llvm::Function::iterator I = Fn->begin(), E = Fn->end(); I != E; I++) {
 272       llvm::Instruction *T = I->getTerminator();
 273       if (isa<llvm::ReturnInst>(T)) {
 274         RValue RV = RValue::get(T->getOperand(0));
 275         T->eraseFromParent();
 276         Builder.SetInsertPoint(&*I);
 277         RV = PerformReturnAdjustment(*this, ResultType, RV, Thunk);
 278         Builder.CreateRet(RV.getScalarVal());
 279         break;
 280       }
 281     }
 282   }
 283 }
 284
 285 void CodeGenFunction::GenerateThunk(llvm::Function *Fn,
 286                                     const CGFunctionInfo &FnInfo,
 287                                     GlobalDecl GD, const ThunkInfo &Thunk) {
 288   const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
 289   const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
 290   QualType ResultType = FPT->getResultType();
 291   QualType ThisType = MD->getThisType(getContext());
 292
 293   FunctionArgList FunctionArgs;
 294
 295   // FIXME: It would be nice if more of this code could be shared with
 296   // CodeGenFunction::GenerateCode.
 297
 298   // Create the implicit 'this' parameter declaration.
 299   CurGD = GD;
 300   CGM.getCXXABI().BuildInstanceFunctionParams(*this, ResultType, FunctionArgs);
 301
 302   // Add the rest of the parameters.
 303   for (FunctionDecl::param_const_iterator I = MD->param_begin(),
 304        E = MD->param_end(); I != E; ++I) {
 305     ParmVarDecl *Param = *I;
 306
 307     FunctionArgs.push_back(Param);
 308   }
 309
 310   // Initialize debug info if needed.
 311   maybeInitializeDebugInfo();
 312
 313   StartFunction(GlobalDecl(), ResultType, Fn, FnInfo, FunctionArgs,
 314                 SourceLocation());
 315
 316   CGM.getCXXABI().EmitInstanceFunctionProlog(*this);
 317   CXXThisValue = CXXABIThisValue;
 318
 319   // Adjust the 'this' pointer if necessary.
 320   llvm::Value *AdjustedThisPtr =
 321     PerformTypeAdjustment(*this, LoadCXXThis(),
 322                           Thunk.This.NonVirtual,
 323                           Thunk.This.VCallOffsetOffset,
 324                           /*IsReturnAdjustment*/false);
 325
 326   CallArgList CallArgs;
 327
 328   // Add our adjusted 'this' pointer.
 329   CallArgs.add(RValue::get(AdjustedThisPtr), ThisType);
 330
 331   // Add the rest of the parameters.
 332   for (FunctionDecl::param_const_iterator I = MD->param_begin(),
 333        E = MD->param_end(); I != E; ++I) {
 334     ParmVarDecl *param = *I;
 335     EmitDelegateCallArg(CallArgs, param);
 336   }
 337
 338   // Get our callee.
 339   llvm::Type *Ty =
 340     CGM.getTypes().GetFunctionType(CGM.getTypes().arrangeGlobalDeclaration(GD));
 341   llvm::Value *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true);
 342
 343 #ifndef NDEBUG
 344   const CGFunctionInfo &CallFnInfo =
 345     CGM.getTypes().arrangeCXXMethodCall(CallArgs, FPT,
 346                                        RequiredArgs::forPrototypePlus(FPT, 1));
 347   assert(CallFnInfo.getRegParm() == FnInfo.getRegParm() &&
 348          CallFnInfo.isNoReturn() == FnInfo.isNoReturn() &&
 349          CallFnInfo.getCallingConvention() == FnInfo.getCallingConvention());
 350   assert(isa<CXXDestructorDecl>(MD) || // ignore dtor return types
 351          similar(CallFnInfo.getReturnInfo(), CallFnInfo.getReturnType(),
 352                  FnInfo.getReturnInfo(), FnInfo.getReturnType()));
 353   assert(CallFnInfo.arg_size() == FnInfo.arg_size());
 354   for (unsigned i = 0, e = FnInfo.arg_size(); i != e; ++i)
 355     assert(similar(CallFnInfo.arg_begin()[i].info,
 356                    CallFnInfo.arg_begin()[i].type,
 357                    FnInfo.arg_begin()[i].info, FnInfo.arg_begin()[i].type));
 358 #endif
 359
 360   // Determine whether we have a return value slot to use.
 361   ReturnValueSlot Slot;
 362   if (!ResultType->isVoidType() &&
 363       FnInfo.getReturnInfo().getKind() == ABIArgInfo::Indirect &&
 364       !hasScalarEvaluationKind(CurFnInfo->getReturnType()))
 365     Slot = ReturnValueSlot(ReturnValue, ResultType.isVolatileQualified());
 366
 367   // Now emit our call.
 368   RValue RV = EmitCall(FnInfo, Callee, Slot, CallArgs, MD);
 369
 370   if (!Thunk.Return.isEmpty())
 371     RV = PerformReturnAdjustment(*this, ResultType, RV, Thunk);
 372
 373   if (!ResultType->isVoidType() && Slot.isNull())
 374     CGM.getCXXABI().EmitReturnFromThunk(*this, RV, ResultType);
 375
 376   // Disable the final ARC autorelease.
 377   AutoreleaseResult = false;
 378
 379   FinishFunction();
 380
 381   // Set the right linkage.
 382   CGM.setFunctionLinkage(MD, Fn);
 383
 384   // Set the right visibility.
 385   setThunkVisibility(CGM, MD, Thunk, Fn);
 386 }
 387
 388 void CodeGenVTables::EmitThunk(GlobalDecl GD, const ThunkInfo &Thunk,
 389                                bool UseAvailableExternallyLinkage)
 390 {
 391   const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeGlobalDeclaration(GD);
 392
 393   // FIXME: re-use FnInfo in this computation.
 394   llvm::Constant *Entry = CGM.GetAddrOfThunk(GD, Thunk);
 395
 396   // Strip off a bitcast if we got one back.
 397   if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
 398     assert(CE->getOpcode() == llvm::Instruction::BitCast);
 399     Entry = CE->getOperand(0);
 400   }
 401
 402   // There's already a declaration with the same name, check if it has the same
 403   // type or if we need to replace it.
 404   if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() !=
 405       CGM.getTypes().GetFunctionTypeForVTable(GD)) {
 406     llvm::GlobalValue *OldThunkFn = cast<llvm::GlobalValue>(Entry);
 407
 408     // If the types mismatch then we have to rewrite the definition.
 409     assert(OldThunkFn->isDeclaration() &&
 410            "Shouldn't replace non-declaration");
 411
 412     // Remove the name from the old thunk function and get a new thunk.
 413     OldThunkFn->setName(StringRef());
 414     Entry = CGM.GetAddrOfThunk(GD, Thunk);
 415
 416     // If needed, replace the old thunk with a bitcast.
 417     if (!OldThunkFn->use_empty()) {
 418       llvm::Constant *NewPtrForOldDecl =
 419         llvm::ConstantExpr::getBitCast(Entry, OldThunkFn->getType());
 420       OldThunkFn->replaceAllUsesWith(NewPtrForOldDecl);
 421     }
 422
 423     // Remove the old thunk.
 424     OldThunkFn->eraseFromParent();
 425   }
 426
 427   llvm::Function *ThunkFn = cast<llvm::Function>(Entry);
 428
 429   if (!ThunkFn->isDeclaration()) {
 430     if (UseAvailableExternallyLinkage) {
 431       // There is already a thunk emitted for this function, do nothing.
 432       return;
 433     }
 434
 435     // If a function has a body, it should have available_externally linkage.
 436     assert(ThunkFn->hasAvailableExternallyLinkage() &&
 437            "Function should have available_externally linkage!");
 438
 439     // Change the linkage.
 440     CGM.setFunctionLinkage(cast<CXXMethodDecl>(GD.getDecl()), ThunkFn);
 441     return;
 442   }
 443
 444   CGM.SetLLVMFunctionAttributesForDefinition(GD.getDecl(), ThunkFn);
 445
 446   if (ThunkFn->isVarArg()) {
 447     // Varargs thunks are special; we can't just generate a call because
 448     // we can't copy the varargs.  Our implementation is rather
 449     // expensive/sucky at the moment, so don't generate the thunk unless
 450     // we have to.
 451     // FIXME: Do something better here; GenerateVarArgsThunk is extremely ugly.
 452     if (!UseAvailableExternallyLinkage)
 453       CodeGenFunction(CGM).GenerateVarArgsThunk(ThunkFn, FnInfo, GD, Thunk);
 454   } else {
 455     // Normal thunk body generation.
 456     CodeGenFunction(CGM).GenerateThunk(ThunkFn, FnInfo, GD, Thunk);
 457     if (UseAvailableExternallyLinkage)
 458       ThunkFn->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
 459   }
 460 }
 461
 462 void CodeGenVTables::MaybeEmitThunkAvailableExternally(GlobalDecl GD,
 463                                                        const ThunkInfo &Thunk) {
 464   // We only want to do this when building with optimizations.
 465   if (!CGM.getCodeGenOpts().OptimizationLevel)
 466     return;
 467
 468   // We can't emit thunks for member functions with incomplete types.
 469   const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
 470   if (!CGM.getTypes().isFuncTypeConvertible(
 471                                 cast<FunctionType>(MD->getType().getTypePtr())))
 472     return;
 473
 474   EmitThunk(GD, Thunk, /*UseAvailableExternallyLinkage=*/true);
 475 }
 476
 477 void CodeGenVTables::EmitThunks(GlobalDecl GD)
 478 {
 479   const CXXMethodDecl *MD =
 480     cast<CXXMethodDecl>(GD.getDecl())->getCanonicalDecl();
 481
 482   // We don't need to generate thunks for the base destructor.
 483   if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() == Dtor_Base)
 484     return;
 485
 486   const VTableContext::ThunkInfoVectorTy *ThunkInfoVector =
 487     VTContext.getThunkInfo(MD);
 488   if (!ThunkInfoVector)
 489     return;
 490
 491   for (unsigned I = 0, E = ThunkInfoVector->size(); I != E; ++I)
 492     EmitThunk(GD, (*ThunkInfoVector)[I],
 493               /*UseAvailableExternallyLinkage=*/false);
 494 }
 495
 496 llvm::Constant *
 497 CodeGenVTables::CreateVTableInitializer(const CXXRecordDecl *RD,
 498                                         const VTableComponent *Components,
 499                                         unsigned NumComponents,
 500                                 const VTableLayout::VTableThunkTy *VTableThunks,
 501                                         unsigned NumVTableThunks) {
 502   SmallVector<llvm::Constant *, 64> Inits;
 503
 504   llvm::Type *Int8PtrTy = CGM.Int8PtrTy;
 505
 506   llvm::Type *PtrDiffTy =
 507     CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
 508
 509   QualType ClassType = CGM.getContext().getTagDeclType(RD);
 510   llvm::Constant *RTTI = CGM.GetAddrOfRTTIDescriptor(ClassType);
 511
 512   unsigned NextVTableThunkIndex = 0;
 513
 514   llvm::Constant *PureVirtualFn = 0, *DeletedVirtualFn = 0;
 515
 516   for (unsigned I = 0; I != NumComponents; ++I) {
 517     VTableComponent Component = Components[I];
 518
 519     llvm::Constant *Init = 0;
 520
 521     switch (Component.getKind()) {
 522     case VTableComponent::CK_VCallOffset:
 523       Init = llvm::ConstantInt::get(PtrDiffTy,
 524                                     Component.getVCallOffset().getQuantity());
 525       Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
 526       break;
 527     case VTableComponent::CK_VBaseOffset:
 528       Init = llvm::ConstantInt::get(PtrDiffTy,
 529                                     Component.getVBaseOffset().getQuantity());
 530       Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
 531       break;
 532     case VTableComponent::CK_OffsetToTop:
 533       Init = llvm::ConstantInt::get(PtrDiffTy,
 534                                     Component.getOffsetToTop().getQuantity());
 535       Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
 536       break;
 537     case VTableComponent::CK_RTTI:
 538       Init = llvm::ConstantExpr::getBitCast(RTTI, Int8PtrTy);
 539       break;
 540     case VTableComponent::CK_FunctionPointer:
 541     case VTableComponent::CK_CompleteDtorPointer:
 542     case VTableComponent::CK_DeletingDtorPointer: {
 543       GlobalDecl GD;
 544
 545       // Get the right global decl.
 546       switch (Component.getKind()) {
 547       default:
 548         llvm_unreachable("Unexpected vtable component kind");
 549       case VTableComponent::CK_FunctionPointer:
 550         GD = Component.getFunctionDecl();
 551         break;
 552       case VTableComponent::CK_CompleteDtorPointer:
 553         GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Complete);
 554         break;
 555       case VTableComponent::CK_DeletingDtorPointer:
 556         GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Deleting);
 557         break;
 558       }
 559
 560       if (cast<CXXMethodDecl>(GD.getDecl())->isPure()) {
 561         // We have a pure virtual member function.
 562         if (!PureVirtualFn) {
 563           llvm::FunctionType *Ty =
 564             llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
 565           StringRef PureCallName = CGM.getCXXABI().GetPureVirtualCallName();
 566           PureVirtualFn = CGM.CreateRuntimeFunction(Ty, PureCallName);
 567           PureVirtualFn = llvm::ConstantExpr::getBitCast(PureVirtualFn,
 568                                                          CGM.Int8PtrTy);
 569         }
 570         Init = PureVirtualFn;
 571       } else if (cast<CXXMethodDecl>(GD.getDecl())->isDeleted()) {
 572         if (!DeletedVirtualFn) {
 573           llvm::FunctionType *Ty =
 574             llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
 575           StringRef DeletedCallName =
 576             CGM.getCXXABI().GetDeletedVirtualCallName();
 577           DeletedVirtualFn = CGM.CreateRuntimeFunction(Ty, DeletedCallName);
 578           DeletedVirtualFn = llvm::ConstantExpr::getBitCast(DeletedVirtualFn,
 579                                                          CGM.Int8PtrTy);
 580         }
 581         Init = DeletedVirtualFn;
 582       } else {
 583         // Check if we should use a thunk.
 584         if (NextVTableThunkIndex < NumVTableThunks &&
 585             VTableThunks[NextVTableThunkIndex].first == I) {
 586           const ThunkInfo &Thunk = VTableThunks[NextVTableThunkIndex].second;
 587
 588           MaybeEmitThunkAvailableExternally(GD, Thunk);
 589           Init = CGM.GetAddrOfThunk(GD, Thunk);
 590
 591           NextVTableThunkIndex++;
 592         } else {
 593           llvm::Type *Ty = CGM.getTypes().GetFunctionTypeForVTable(GD);
 594
 595           Init = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true);
 596         }
 597
 598         Init = llvm::ConstantExpr::getBitCast(Init, Int8PtrTy);
 599       }
 600       break;
 601     }
 602
 603     case VTableComponent::CK_UnusedFunctionPointer:
 604       Init = llvm::ConstantExpr::getNullValue(Int8PtrTy);
 605       break;
 606     };
 607
 608     Inits.push_back(Init);
 609   }
 610
 611   llvm::ArrayType *ArrayType = llvm::ArrayType::get(Int8PtrTy, NumComponents);
 612   return llvm::ConstantArray::get(ArrayType, Inits);
 613 }
 614
 615 llvm::GlobalVariable *CodeGenVTables::GetAddrOfVTable(const CXXRecordDecl *RD) {
 616   llvm::GlobalVariable *&VTable = VTables[RD];
 617   if (VTable)
 618     return VTable;
 619
 620   // Queue up this v-table for possible deferred emission.
 621   CGM.addDeferredVTable(RD);
 622
 623   SmallString<256> OutName;
 624   llvm::raw_svector_ostream Out(OutName);
 625   CGM.getCXXABI().getMangleContext().mangleCXXVTable(RD, Out);
 626   Out.flush();
 627   StringRef Name = OutName.str();
 628
 629   llvm::ArrayType *ArrayType =
 630     llvm::ArrayType::get(CGM.Int8PtrTy,
 631                         VTContext.getVTableLayout(RD).getNumVTableComponents());
 632
 633   VTable =
 634     CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType,
 635                                           llvm::GlobalValue::ExternalLinkage);
 636   VTable->setUnnamedAddr(true);
 637   return VTable;
 638 }
 639
 640 void
 641 CodeGenVTables::EmitVTableDefinition(llvm::GlobalVariable *VTable,
 642                                      llvm::GlobalVariable::LinkageTypes Linkage,
 643                                      const CXXRecordDecl *RD) {
 644   const VTableLayout &VTLayout = VTContext.getVTableLayout(RD);
 645
 646   // Create and set the initializer.
 647   llvm::Constant *Init =
 648     CreateVTableInitializer(RD,
 649                             VTLayout.vtable_component_begin(),
 650                             VTLayout.getNumVTableComponents(),
 651                             VTLayout.vtable_thunk_begin(),
 652                             VTLayout.getNumVTableThunks());
 653   VTable->setInitializer(Init);
 654
 655   // Set the correct linkage.
 656   VTable->setLinkage(Linkage);
 657
 658   // Set the right visibility.
 659   CGM.setTypeVisibility(VTable, RD, CodeGenModule::TVK_ForVTable);
 660 }
 661
 662 llvm::GlobalVariable *
 663 CodeGenVTables::GenerateConstructionVTable(const CXXRecordDecl *RD,
 664                                       const BaseSubobject &Base,
 665                                       bool BaseIsVirtual,
 666                                    llvm::GlobalVariable::LinkageTypes Linkage,
 667                                       VTableAddressPointsMapTy& AddressPoints) {
 668   OwningPtr<VTableLayout> VTLayout(
 669     VTContext.createConstructionVTableLayout(Base.getBase(),
 670                                              Base.getBaseOffset(),
 671                                              BaseIsVirtual, RD));
 672
 673   // Add the address points.
 674   AddressPoints = VTLayout->getAddressPoints();
 675
 676   // Get the mangled construction vtable name.
 677   SmallString<256> OutName;
 678   llvm::raw_svector_ostream Out(OutName);
 679   CGM.getCXXABI().getMangleContext().
 680     mangleCXXCtorVTable(RD, Base.getBaseOffset().getQuantity(), Base.getBase(),
 681                         Out);
 682   Out.flush();
 683   StringRef Name = OutName.str();
 684
 685   llvm::ArrayType *ArrayType =
 686     llvm::ArrayType::get(CGM.Int8PtrTy, VTLayout->getNumVTableComponents());
 687
 688   // Construction vtable symbols are not part of the Itanium ABI, so we cannot
 689   // guarantee that they actually will be available externally. Instead, when
 690   // emitting an available_externally VTT, we provide references to an internal
 691   // linkage construction vtable. The ABI only requires complete-object vtables
 692   // to be the same for all instances of a type, not construction vtables.
 693   if (Linkage == llvm::GlobalVariable::AvailableExternallyLinkage)
 694     Linkage = llvm::GlobalVariable::InternalLinkage;
 695
 696   // Create the variable that will hold the construction vtable.
 697   llvm::GlobalVariable *VTable =
 698     CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType, Linkage);
 699   CGM.setTypeVisibility(VTable, RD, CodeGenModule::TVK_ForConstructionVTable);
 700
 701   // V-tables are always unnamed_addr.
 702   VTable->setUnnamedAddr(true);
 703
 704   // Create and set the initializer.
 705   llvm::Constant *Init =
 706     CreateVTableInitializer(Base.getBase(),
 707                             VTLayout->vtable_component_begin(),
 708                             VTLayout->getNumVTableComponents(),
 709                             VTLayout->vtable_thunk_begin(),
 710                             VTLayout->getNumVTableThunks());
 711   VTable->setInitializer(Init);
 712
 713   return VTable;
 714 }
 715
 716 /// Compute the required linkage of the v-table for the given class.
 717 ///
 718 /// Note that we only call this at the end of the translation unit.
 719 llvm::GlobalVariable::LinkageTypes
 720 CodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) {
 721   if (RD->getLinkage() != ExternalLinkage)
 722     return llvm::GlobalVariable::InternalLinkage;
 723
 724   // We're at the end of the translation unit, so the current key
 725   // function is fully correct.
 726   if (const CXXMethodDecl *keyFunction = Context.getCurrentKeyFunction(RD)) {
 727     // If this class has a key function, use that to determine the
 728     // linkage of the vtable.
 729     const FunctionDecl *def = 0;
 730     if (keyFunction->hasBody(def))
 731       keyFunction = cast<CXXMethodDecl>(def);
 732
 733     switch (keyFunction->getTemplateSpecializationKind()) {
 734       case TSK_Undeclared:
 735       case TSK_ExplicitSpecialization:
 736         // When compiling with optimizations turned on, we emit all vtables,
 737         // even if the key function is not defined in the current translation
 738         // unit. If this is the case, use available_externally linkage.
 739         if (!def && CodeGenOpts.OptimizationLevel)
 740           return llvm::GlobalVariable::AvailableExternallyLinkage;
 741
 742         if (keyFunction->isInlined())
 743           return !Context.getLangOpts().AppleKext ?
 744                    llvm::GlobalVariable::LinkOnceODRLinkage :
 745                    llvm::Function::InternalLinkage;
 746
 747         return llvm::GlobalVariable::ExternalLinkage;
 748
 749       case TSK_ImplicitInstantiation:
 750         return !Context.getLangOpts().AppleKext ?
 751                  llvm::GlobalVariable::LinkOnceODRLinkage :
 752                  llvm::Function::InternalLinkage;
 753
 754       case TSK_ExplicitInstantiationDefinition:
 755         return !Context.getLangOpts().AppleKext ?
 756                  llvm::GlobalVariable::WeakODRLinkage :
 757                  llvm::Function::InternalLinkage;
 758
 759       case TSK_ExplicitInstantiationDeclaration:
 760         return !Context.getLangOpts().AppleKext ?
 761                  llvm::GlobalVariable::AvailableExternallyLinkage :
 762                  llvm::Function::InternalLinkage;
 763     }
 764   }
 765
 766   // -fapple-kext mode does not support weak linkage, so we must use
 767   // internal linkage.
 768   if (Context.getLangOpts().AppleKext)
 769     return llvm::Function::InternalLinkage;
 770
 771   switch (RD->getTemplateSpecializationKind()) {
 772   case TSK_Undeclared:
 773   case TSK_ExplicitSpecialization:
 774   case TSK_ImplicitInstantiation:
 775     return llvm::GlobalVariable::LinkOnceODRLinkage;
 776
 777   case TSK_ExplicitInstantiationDeclaration:
 778     return llvm::GlobalVariable::AvailableExternallyLinkage;
 779
 780   case TSK_ExplicitInstantiationDefinition:
 781       return llvm::GlobalVariable::WeakODRLinkage;
 782   }
 783
 784   llvm_unreachable("Invalid TemplateSpecializationKind!");
 785 }
 786
 787 /// This is a callback from Sema to tell us that it believes that a
 788 /// particular v-table is required to be emitted in this translation
 789 /// unit.
 790 ///
 791 /// The reason we don't simply trust this callback is because Sema
 792 /// will happily report that something is used even when it's used
 793 /// only in code that we don't actually have to emit.
 794 ///
 795 /// \param isRequired - if true, the v-table is mandatory, e.g.
 796 ///   because the translation unit defines the key function
 797 void CodeGenModule::EmitVTable(CXXRecordDecl *theClass, bool isRequired) {
 798   if (!isRequired) return;
 799
 800   VTables.GenerateClassData(theClass);
 801 }
 802
 803 void
 804 CodeGenVTables::GenerateClassData(const CXXRecordDecl *RD) {
 805   // First off, check whether we've already emitted the v-table and
 806   // associated stuff.
 807   llvm::GlobalVariable *VTable = GetAddrOfVTable(RD);
 808   if (VTable->hasInitializer())
 809     return;
 810
 811   llvm::GlobalVariable::LinkageTypes Linkage = CGM.getVTableLinkage(RD);
 812   EmitVTableDefinition(VTable, Linkage, RD);
 813
 814   if (RD->getNumVBases()) {
 815     if (!CGM.getTarget().getCXXABI().isMicrosoft()) {
 816       llvm::GlobalVariable *VTT = GetAddrOfVTT(RD);
 817       EmitVTTDefinition(VTT, Linkage, RD);
 818     } else {
 819       // FIXME: Emit vbtables here.
 820     }
 821   }
 822
 823   // If this is the magic class __cxxabiv1::__fundamental_type_info,
 824   // we will emit the typeinfo for the fundamental types. This is the
 825   // same behaviour as GCC.
 826   const DeclContext *DC = RD->getDeclContext();
 827   if (RD->getIdentifier() &&
 828       RD->getIdentifier()->isStr("__fundamental_type_info") &&
 829       isa<NamespaceDecl>(DC) &&
 830       cast<NamespaceDecl>(DC)->getIdentifier() &&
 831       cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__cxxabiv1") &&
 832       DC->getParent()->isTranslationUnit())
 833     CGM.EmitFundamentalRTTIDescriptors();
 834 }
 835
 836 /// At this point in the translation unit, does it appear that can we
 837 /// rely on the vtable being defined elsewhere in the program?
 838 ///
 839 /// The response is really only definitive when called at the end of
 840 /// the translation unit.
 841 ///
 842 /// The only semantic restriction here is that the object file should
 843 /// not contain a v-table definition when that v-table is defined
 844 /// strongly elsewhere.  Otherwise, we'd just like to avoid emitting
 845 /// v-tables when unnecessary.
 846 bool CodeGenVTables::isVTableExternal(const CXXRecordDecl *RD) {
 847   assert(RD->isDynamicClass() && "Non dynamic classes have no VTable.");
 848
 849   // If we have an explicit instantiation declaration (and not a
 850   // definition), the v-table is defined elsewhere.
 851   TemplateSpecializationKind TSK = RD->getTemplateSpecializationKind();
 852   if (TSK == TSK_ExplicitInstantiationDeclaration)
 853     return true;
 854
 855   // Otherwise, if the class is an instantiated template, the
 856   // v-table must be defined here.
 857   if (TSK == TSK_ImplicitInstantiation ||
 858       TSK == TSK_ExplicitInstantiationDefinition)
 859     return false;
 860
 861   // Otherwise, if the class doesn't have a key function (possibly
 862   // anymore), the v-table must be defined here.
 863   const CXXMethodDecl *keyFunction = CGM.getContext().getCurrentKeyFunction(RD);
 864   if (!keyFunction)
 865     return false;
 866
 867   // Otherwise, if we don't have a definition of the key function, the
 868   // v-table must be defined somewhere else.
 869   return !keyFunction->hasBody();
 870 }
 871
 872 /// Given that we're currently at the end of the translation unit, and
 873 /// we've emitted a reference to the v-table for this class, should
 874 /// we define that v-table?
 875 static bool shouldEmitVTableAtEndOfTranslationUnit(CodeGenModule &CGM,
 876                                                    const CXXRecordDecl *RD) {
 877   // If we're building with optimization, we always emit v-tables
 878   // since that allows for virtual function calls to be devirtualized.
 879   // If the v-table is defined strongly elsewhere, this definition
 880   // will be emitted available_externally.
 881   //
 882   // However, we don't want to do this in -fapple-kext mode, because
 883   // kext mode does not permit devirtualization.
 884   if (CGM.getCodeGenOpts().OptimizationLevel && !CGM.getLangOpts().AppleKext)
 885     return true;
 886
 887   return !CGM.getVTables().isVTableExternal(RD);
 888 }
 889
 890 /// Given that at some point we emitted a reference to one or more
 891 /// v-tables, and that we are now at the end of the translation unit,
 892 /// decide whether we should emit them.
 893 void CodeGenModule::EmitDeferredVTables() {
 894 #ifndef NDEBUG
 895   // Remember the size of DeferredVTables, because we're going to assume
 896   // that this entire operation doesn't modify it.
 897   size_t savedSize = DeferredVTables.size();
 898 #endif
 899
 900   typedef std::vector<const CXXRecordDecl *>::const_iterator const_iterator;
 901   for (const_iterator i = DeferredVTables.begin(),
 902                       e = DeferredVTables.end(); i != e; ++i) {
 903     const CXXRecordDecl *RD = *i;
 904     if (shouldEmitVTableAtEndOfTranslationUnit(*this, RD))
 905       VTables.GenerateClassData(RD);
 906   }
 907
 908   assert(savedSize == DeferredVTables.size() &&
 909          "deferred extra v-tables during v-table emission?");
 910   DeferredVTables.clear();
 911 }