Home | History | Annotate | Download | only in CodeGen 
      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 "CodeGenModule.h"
     15 #include "CodeGenFunction.h"
     16 #include "CGCXXABI.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 bool CodeGenVTables::ShouldEmitVTableInThisTU(const CXXRecordDecl *RD) {
     35   assert(RD->isDynamicClass() && "Non dynamic classes have no VTable.");
     36 
     37   TemplateSpecializationKind TSK = RD->getTemplateSpecializationKind();
     38   if (TSK == TSK_ExplicitInstantiationDeclaration)
     39     return false;
     40 
     41   const CXXMethodDecl *KeyFunction = CGM.getContext().getKeyFunction(RD);
     42   if (!KeyFunction)
     43     return true;
     44 
     45   // Itanium C++ ABI, 5.2.6 Instantiated Templates:
     46   //    An instantiation of a class template requires:
     47   //        - In the object where instantiated, the virtual table...
     48   if (TSK == TSK_ImplicitInstantiation ||
     49       TSK == TSK_ExplicitInstantiationDefinition)
     50     return true;
     51 
     52   // If we're building with optimization, we always emit VTables since that
     53   // allows for virtual function calls to be devirtualized.
     54   // (We don't want to do this in -fapple-kext mode however).
     55   if (CGM.getCodeGenOpts().OptimizationLevel && !CGM.getLangOpts().AppleKext)
     56     return true;
     57 
     58   return KeyFunction->hasBody();
     59 }
     60 
     61 llvm::Constant *CodeGenModule::GetAddrOfThunk(GlobalDecl GD,
     62                                               const ThunkInfo &Thunk) {
     63   const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
     64 
     65   // Compute the mangled name.
     66   SmallString<256> Name;
     67   llvm::raw_svector_ostream Out(Name);
     68   if (const CXXDestructorDecl* DD = dyn_cast<CXXDestructorDecl>(MD))
     69     getCXXABI().getMangleContext().mangleCXXDtorThunk(DD, GD.getDtorType(),
     70                                                       Thunk.This, Out);
     71   else
     72     getCXXABI().getMangleContext().mangleThunk(MD, Thunk, Out);
     73   Out.flush();
     74 
     75   llvm::Type *Ty = getTypes().GetFunctionTypeForVTable(GD);
     76   return GetOrCreateLLVMFunction(Name, Ty, GD, /*ForVTable=*/true);
     77 }
     78 
     79 static llvm::Value *PerformTypeAdjustment(CodeGenFunction &CGF,
     80                                           llvm::Value *Ptr,
     81                                           int64_t NonVirtualAdjustment,
     82                                           int64_t VirtualAdjustment) {
     83   if (!NonVirtualAdjustment && !VirtualAdjustment)
     84     return Ptr;
     85 
     86   llvm::Type *Int8PtrTy = CGF.Int8PtrTy;
     87   llvm::Value *V = CGF.Builder.CreateBitCast(Ptr, Int8PtrTy);
     88 
     89   if (NonVirtualAdjustment) {
     90     // Do the non-virtual adjustment.
     91     V = CGF.Builder.CreateConstInBoundsGEP1_64(V, NonVirtualAdjustment);
     92   }
     93 
     94   if (VirtualAdjustment) {
     95     llvm::Type *PtrDiffTy =
     96       CGF.ConvertType(CGF.getContext().getPointerDiffType());
     97 
     98     // Do the virtual adjustment.
     99     llvm::Value *VTablePtrPtr =
    100       CGF.Builder.CreateBitCast(V, Int8PtrTy->getPointerTo());
    101 
    102     llvm::Value *VTablePtr = CGF.Builder.CreateLoad(VTablePtrPtr);
    103 
    104     llvm::Value *OffsetPtr =
    105       CGF.Builder.CreateConstInBoundsGEP1_64(VTablePtr, VirtualAdjustment);
    106 
    107     OffsetPtr = CGF.Builder.CreateBitCast(OffsetPtr, PtrDiffTy->getPointerTo());
    108 
    109     // Load the adjustment offset from the vtable.
    110     llvm::Value *Offset = CGF.Builder.CreateLoad(OffsetPtr);
    111 
    112     // Adjust our pointer.
    113     V = CGF.Builder.CreateInBoundsGEP(V, Offset);
    114   }
    115 
    116   // Cast back to the original type.
    117   return CGF.Builder.CreateBitCast(V, Ptr->getType());
    118 }
    119 
    120 static void setThunkVisibility(CodeGenModule &CGM, const CXXMethodDecl *MD,
    121                                const ThunkInfo &Thunk, llvm::Function *Fn) {
    122   CGM.setGlobalVisibility(Fn, MD);
    123 
    124   if (!CGM.getCodeGenOpts().HiddenWeakVTables)
    125     return;
    126 
    127   // If the thunk has weak/linkonce linkage, but the function must be
    128   // emitted in every translation unit that references it, then we can
    129   // emit its thunks with hidden visibility, since its thunks must be
    130   // emitted when the function is.
    131 
    132   // This follows CodeGenModule::setTypeVisibility; see the comments
    133   // there for explanation.
    134 
    135   if ((Fn->getLinkage() != llvm::GlobalVariable::LinkOnceODRLinkage &&
    136        Fn->getLinkage() != llvm::GlobalVariable::WeakODRLinkage) ||
    137       Fn->getVisibility() != llvm::GlobalVariable::DefaultVisibility)
    138     return;
    139 
    140   if (MD->getExplicitVisibility())
    141     return;
    142 
    143   switch (MD->getTemplateSpecializationKind()) {
    144   case TSK_ExplicitInstantiationDefinition:
    145   case TSK_ExplicitInstantiationDeclaration:
    146     return;
    147 
    148   case TSK_Undeclared:
    149     break;
    150 
    151   case TSK_ExplicitSpecialization:
    152   case TSK_ImplicitInstantiation:
    153     if (!CGM.getCodeGenOpts().HiddenWeakTemplateVTables)
    154       return;
    155     break;
    156   }
    157 
    158   // If there's an explicit definition, and that definition is
    159   // out-of-line, then we can't assume that all users will have a
    160   // definition to emit.
    161   const FunctionDecl *Def = 0;
    162   if (MD->hasBody(Def) && Def->isOutOfLine())
    163     return;
    164 
    165   Fn->setVisibility(llvm::GlobalValue::HiddenVisibility);
    166 }
    167 
    168 #ifndef NDEBUG
    169 static bool similar(const ABIArgInfo &infoL, CanQualType typeL,
    170                     const ABIArgInfo &infoR, CanQualType typeR) {
    171   return (infoL.getKind() == infoR.getKind() &&
    172           (typeL == typeR ||
    173            (isa<PointerType>(typeL) && isa<PointerType>(typeR)) ||
    174            (isa<ReferenceType>(typeL) && isa<ReferenceType>(typeR))));
    175 }
    176 #endif
    177 
    178 static RValue PerformReturnAdjustment(CodeGenFunction &CGF,
    179                                       QualType ResultType, RValue RV,
    180                                       const ThunkInfo &Thunk) {
    181   // Emit the return adjustment.
    182   bool NullCheckValue = !ResultType->isReferenceType();
    183 
    184   llvm::BasicBlock *AdjustNull = 0;
    185   llvm::BasicBlock *AdjustNotNull = 0;
    186   llvm::BasicBlock *AdjustEnd = 0;
    187 
    188   llvm::Value *ReturnValue = RV.getScalarVal();
    189 
    190   if (NullCheckValue) {
    191     AdjustNull = CGF.createBasicBlock("adjust.null");
    192     AdjustNotNull = CGF.createBasicBlock("adjust.notnull");
    193     AdjustEnd = CGF.createBasicBlock("adjust.end");
    194 
    195     llvm::Value *IsNull = CGF.Builder.CreateIsNull(ReturnValue);
    196     CGF.Builder.CreateCondBr(IsNull, AdjustNull, AdjustNotNull);
    197     CGF.EmitBlock(AdjustNotNull);
    198   }
    199 
    200   ReturnValue = PerformTypeAdjustment(CGF, ReturnValue,
    201                                       Thunk.Return.NonVirtual,
    202                                       Thunk.Return.VBaseOffsetOffset);
    203 
    204   if (NullCheckValue) {
    205     CGF.Builder.CreateBr(AdjustEnd);
    206     CGF.EmitBlock(AdjustNull);
    207     CGF.Builder.CreateBr(AdjustEnd);
    208     CGF.EmitBlock(AdjustEnd);
    209 
    210     llvm::PHINode *PHI = CGF.Builder.CreatePHI(ReturnValue->getType(), 2);
    211     PHI->addIncoming(ReturnValue, AdjustNotNull);
    212     PHI->addIncoming(llvm::Constant::getNullValue(ReturnValue->getType()),
    213                      AdjustNull);
    214     ReturnValue = PHI;
    215   }
    216 
    217   return RValue::get(ReturnValue);
    218 }
    219 
    220 // This function does roughly the same thing as GenerateThunk, but in a
    221 // very different way, so that va_start and va_end work correctly.
    222 // FIXME: This function assumes "this" is the first non-sret LLVM argument of
    223 //        a function, and that there is an alloca built in the entry block
    224 //        for all accesses to "this".
    225 // FIXME: This function assumes there is only one "ret" statement per function.
    226 // FIXME: Cloning isn't correct in the presence of indirect goto!
    227 // FIXME: This implementation of thunks bloats codesize by duplicating the
    228 //        function definition.  There are alternatives:
    229 //        1. Add some sort of stub support to LLVM for cases where we can
    230 //           do a this adjustment, then a sibcall.
    231 //        2. We could transform the definition to take a va_list instead of an
    232 //           actual variable argument list, then have the thunks (including a
    233 //           no-op thunk for the regular definition) call va_start/va_end.
    234 //           There's a bit of per-call overhead for this solution, but it's
    235 //           better for codesize if the definition is long.
    236 void CodeGenFunction::GenerateVarArgsThunk(
    237                                       llvm::Function *Fn,
    238                                       const CGFunctionInfo &FnInfo,
    239                                       GlobalDecl GD, const ThunkInfo &Thunk) {
    240   const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
    241   const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
    242   QualType ResultType = FPT->getResultType();
    243 
    244   // Get the original function
    245   assert(FnInfo.isVariadic());
    246   llvm::Type *Ty = CGM.getTypes().GetFunctionType(FnInfo);
    247   llvm::Value *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true);
    248   llvm::Function *BaseFn = cast<llvm::Function>(Callee);
    249 
    250   // Clone to thunk.
    251   llvm::Function *NewFn = llvm::CloneFunction(BaseFn);
    252   CGM.getModule().getFunctionList().push_back(NewFn);
    253   Fn->replaceAllUsesWith(NewFn);
    254   NewFn->takeName(Fn);
    255   Fn->eraseFromParent();
    256   Fn = NewFn;
    257 
    258   // "Initialize" CGF (minimally).
    259   CurFn = Fn;
    260 
    261   // Get the "this" value
    262   llvm::Function::arg_iterator AI = Fn->arg_begin();
    263   if (CGM.ReturnTypeUsesSRet(FnInfo))
    264     ++AI;
    265 
    266   // Find the first store of "this", which will be to the alloca associated
    267   // with "this".
    268   llvm::Value *ThisPtr = &*AI;
    269   llvm::BasicBlock *EntryBB = Fn->begin();
    270   llvm::Instruction *ThisStore = 0;
    271   for (llvm::BasicBlock::iterator I = EntryBB->begin(), E = EntryBB->end();
    272        I != E; I++) {
    273     if (isa<llvm::StoreInst>(I) && I->getOperand(0) == ThisPtr) {
    274       ThisStore = cast<llvm::StoreInst>(I);
    275       break;
    276     }
    277   }
    278   assert(ThisStore && "Store of this should be in entry block?");
    279   // Adjust "this", if necessary.
    280   Builder.SetInsertPoint(ThisStore);
    281   llvm::Value *AdjustedThisPtr =
    282     PerformTypeAdjustment(*this, ThisPtr,
    283                           Thunk.This.NonVirtual,
    284                           Thunk.This.VCallOffsetOffset);
    285   ThisStore->setOperand(0, AdjustedThisPtr);
    286 
    287   if (!Thunk.Return.isEmpty()) {
    288     // Fix up the returned value, if necessary.
    289     for (llvm::Function::iterator I = Fn->begin(), E = Fn->end(); I != E; I++) {
    290       llvm::Instruction *T = I->getTerminator();
    291       if (isa<llvm::ReturnInst>(T)) {
    292         RValue RV = RValue::get(T->getOperand(0));
    293         T->eraseFromParent();
    294         Builder.SetInsertPoint(&*I);
    295         RV = PerformReturnAdjustment(*this, ResultType, RV, Thunk);
    296         Builder.CreateRet(RV.getScalarVal());
    297         break;
    298       }
    299     }
    300   }
    301 }
    302 
    303 void CodeGenFunction::GenerateThunk(llvm::Function *Fn,
    304                                     const CGFunctionInfo &FnInfo,
    305                                     GlobalDecl GD, const ThunkInfo &Thunk) {
    306   const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
    307   const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
    308   QualType ResultType = FPT->getResultType();
    309   QualType ThisType = MD->getThisType(getContext());
    310 
    311   FunctionArgList FunctionArgs;
    312 
    313   // FIXME: It would be nice if more of this code could be shared with
    314   // CodeGenFunction::GenerateCode.
    315 
    316   // Create the implicit 'this' parameter declaration.
    317   CurGD = GD;
    318   CGM.getCXXABI().BuildInstanceFunctionParams(*this, ResultType, FunctionArgs);
    319 
    320   // Add the rest of the parameters.
    321   for (FunctionDecl::param_const_iterator I = MD->param_begin(),
    322        E = MD->param_end(); I != E; ++I) {
    323     ParmVarDecl *Param = *I;
    324 
    325     FunctionArgs.push_back(Param);
    326   }
    327 
    328   StartFunction(GlobalDecl(), ResultType, Fn, FnInfo, FunctionArgs,
    329                 SourceLocation());
    330 
    331   CGM.getCXXABI().EmitInstanceFunctionProlog(*this);
    332   CXXThisValue = CXXABIThisValue;
    333 
    334   // Adjust the 'this' pointer if necessary.
    335   llvm::Value *AdjustedThisPtr =
    336     PerformTypeAdjustment(*this, LoadCXXThis(),
    337                           Thunk.This.NonVirtual,
    338                           Thunk.This.VCallOffsetOffset);
    339 
    340   CallArgList CallArgs;
    341 
    342   // Add our adjusted 'this' pointer.
    343   CallArgs.add(RValue::get(AdjustedThisPtr), ThisType);
    344 
    345   // Add the rest of the parameters.
    346   for (FunctionDecl::param_const_iterator I = MD->param_begin(),
    347        E = MD->param_end(); I != E; ++I) {
    348     ParmVarDecl *param = *I;
    349     EmitDelegateCallArg(CallArgs, param);
    350   }
    351 
    352   // Get our callee.
    353   llvm::Type *Ty =
    354     CGM.getTypes().GetFunctionType(CGM.getTypes().arrangeGlobalDeclaration(GD));
    355   llvm::Value *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true);
    356 
    357 #ifndef NDEBUG
    358   const CGFunctionInfo &CallFnInfo =
    359     CGM.getTypes().arrangeCXXMethodCall(CallArgs, FPT,
    360                                        RequiredArgs::forPrototypePlus(FPT, 1));
    361   assert(CallFnInfo.getRegParm() == FnInfo.getRegParm() &&
    362          CallFnInfo.isNoReturn() == FnInfo.isNoReturn() &&
    363          CallFnInfo.getCallingConvention() == FnInfo.getCallingConvention());
    364   assert(isa<CXXDestructorDecl>(MD) || // ignore dtor return types
    365          similar(CallFnInfo.getReturnInfo(), CallFnInfo.getReturnType(),
    366                  FnInfo.getReturnInfo(), FnInfo.getReturnType()));
    367   assert(CallFnInfo.arg_size() == FnInfo.arg_size());
    368   for (unsigned i = 0, e = FnInfo.arg_size(); i != e; ++i)
    369     assert(similar(CallFnInfo.arg_begin()[i].info,
    370                    CallFnInfo.arg_begin()[i].type,
    371                    FnInfo.arg_begin()[i].info, FnInfo.arg_begin()[i].type));
    372 #endif
    373 
    374   // Determine whether we have a return value slot to use.
    375   ReturnValueSlot Slot;
    376   if (!ResultType->isVoidType() &&
    377       FnInfo.getReturnInfo().getKind() == ABIArgInfo::Indirect &&
    378       hasAggregateLLVMType(CurFnInfo->getReturnType()))
    379     Slot = ReturnValueSlot(ReturnValue, ResultType.isVolatileQualified());
    380 
    381   // Now emit our call.
    382   RValue RV = EmitCall(FnInfo, Callee, Slot, CallArgs, MD);
    383 
    384   if (!Thunk.Return.isEmpty())
    385     RV = PerformReturnAdjustment(*this, ResultType, RV, Thunk);
    386 
    387   if (!ResultType->isVoidType() && Slot.isNull())
    388     CGM.getCXXABI().EmitReturnFromThunk(*this, RV, ResultType);
    389 
    390   // Disable the final ARC autorelease.
    391   AutoreleaseResult = false;
    392 
    393   FinishFunction();
    394 
    395   // Set the right linkage.
    396   CGM.setFunctionLinkage(MD, Fn);
    397 
    398   // Set the right visibility.
    399   setThunkVisibility(CGM, MD, Thunk, Fn);
    400 }
    401 
    402 void CodeGenVTables::EmitThunk(GlobalDecl GD, const ThunkInfo &Thunk,
    403                                bool UseAvailableExternallyLinkage)
    404 {
    405   const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeGlobalDeclaration(GD);
    406 
    407   // FIXME: re-use FnInfo in this computation.
    408   llvm::Constant *Entry = CGM.GetAddrOfThunk(GD, Thunk);
    409 
    410   // Strip off a bitcast if we got one back.
    411   if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
    412     assert(CE->getOpcode() == llvm::Instruction::BitCast);
    413     Entry = CE->getOperand(0);
    414   }
    415 
    416   // There's already a declaration with the same name, check if it has the same
    417   // type or if we need to replace it.
    418   if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() !=
    419       CGM.getTypes().GetFunctionTypeForVTable(GD)) {
    420     llvm::GlobalValue *OldThunkFn = cast<llvm::GlobalValue>(Entry);
    421 
    422     // If the types mismatch then we have to rewrite the definition.
    423     assert(OldThunkFn->isDeclaration() &&
    424            "Shouldn't replace non-declaration");
    425 
    426     // Remove the name from the old thunk function and get a new thunk.
    427     OldThunkFn->setName(StringRef());
    428     Entry = CGM.GetAddrOfThunk(GD, Thunk);
    429 
    430     // If needed, replace the old thunk with a bitcast.
    431     if (!OldThunkFn->use_empty()) {
    432       llvm::Constant *NewPtrForOldDecl =
    433         llvm::ConstantExpr::getBitCast(Entry, OldThunkFn->getType());
    434       OldThunkFn->replaceAllUsesWith(NewPtrForOldDecl);
    435     }
    436 
    437     // Remove the old thunk.
    438     OldThunkFn->eraseFromParent();
    439   }
    440 
    441   llvm::Function *ThunkFn = cast<llvm::Function>(Entry);
    442 
    443   if (!ThunkFn->isDeclaration()) {
    444     if (UseAvailableExternallyLinkage) {
    445       // There is already a thunk emitted for this function, do nothing.
    446       return;
    447     }
    448 
    449     // If a function has a body, it should have available_externally linkage.
    450     assert(ThunkFn->hasAvailableExternallyLinkage() &&
    451            "Function should have available_externally linkage!");
    452 
    453     // Change the linkage.
    454     CGM.setFunctionLinkage(cast<CXXMethodDecl>(GD.getDecl()), ThunkFn);
    455     return;
    456   }
    457 
    458   if (ThunkFn->isVarArg()) {
    459     // Varargs thunks are special; we can't just generate a call because
    460     // we can't copy the varargs.  Our implementation is rather
    461     // expensive/sucky at the moment, so don't generate the thunk unless
    462     // we have to.
    463     // FIXME: Do something better here; GenerateVarArgsThunk is extremely ugly.
    464     if (!UseAvailableExternallyLinkage)
    465       CodeGenFunction(CGM).GenerateVarArgsThunk(ThunkFn, FnInfo, GD, Thunk);
    466   } else {
    467     // Normal thunk body generation.
    468     CodeGenFunction(CGM).GenerateThunk(ThunkFn, FnInfo, GD, Thunk);
    469   }
    470 
    471   if (UseAvailableExternallyLinkage)
    472     ThunkFn->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
    473 }
    474 
    475 void CodeGenVTables::MaybeEmitThunkAvailableExternally(GlobalDecl GD,
    476                                                        const ThunkInfo &Thunk) {
    477   // We only want to do this when building with optimizations.
    478   if (!CGM.getCodeGenOpts().OptimizationLevel)
    479     return;
    480 
    481   // We can't emit thunks for member functions with incomplete types.
    482   const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
    483   if (!CGM.getTypes().isFuncTypeConvertible(
    484                                 cast<FunctionType>(MD->getType().getTypePtr())))
    485     return;
    486 
    487   EmitThunk(GD, Thunk, /*UseAvailableExternallyLinkage=*/true);
    488 }
    489 
    490 void CodeGenVTables::EmitThunks(GlobalDecl GD)
    491 {
    492   const CXXMethodDecl *MD =
    493     cast<CXXMethodDecl>(GD.getDecl())->getCanonicalDecl();
    494 
    495   // We don't need to generate thunks for the base destructor.
    496   if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() == Dtor_Base)
    497     return;
    498 
    499   const VTableContext::ThunkInfoVectorTy *ThunkInfoVector =
    500     VTContext.getThunkInfo(MD);
    501   if (!ThunkInfoVector)
    502     return;
    503 
    504   for (unsigned I = 0, E = ThunkInfoVector->size(); I != E; ++I)
    505     EmitThunk(GD, (*ThunkInfoVector)[I],
    506               /*UseAvailableExternallyLinkage=*/false);
    507 }
    508 
    509 llvm::Constant *
    510 CodeGenVTables::CreateVTableInitializer(const CXXRecordDecl *RD,
    511                                         const VTableComponent *Components,
    512                                         unsigned NumComponents,
    513                                 const VTableLayout::VTableThunkTy *VTableThunks,
    514                                         unsigned NumVTableThunks) {
    515   SmallVector<llvm::Constant *, 64> Inits;
    516 
    517   llvm::Type *Int8PtrTy = CGM.Int8PtrTy;
    518 
    519   llvm::Type *PtrDiffTy =
    520     CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
    521 
    522   QualType ClassType = CGM.getContext().getTagDeclType(RD);
    523   llvm::Constant *RTTI = CGM.GetAddrOfRTTIDescriptor(ClassType);
    524 
    525   unsigned NextVTableThunkIndex = 0;
    526 
    527   llvm::Constant* PureVirtualFn = 0;
    528 
    529   for (unsigned I = 0; I != NumComponents; ++I) {
    530     VTableComponent Component = Components[I];
    531 
    532     llvm::Constant *Init = 0;
    533 
    534     switch (Component.getKind()) {
    535     case VTableComponent::CK_VCallOffset:
    536       Init = llvm::ConstantInt::get(PtrDiffTy,
    537                                     Component.getVCallOffset().getQuantity());
    538       Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
    539       break;
    540     case VTableComponent::CK_VBaseOffset:
    541       Init = llvm::ConstantInt::get(PtrDiffTy,
    542                                     Component.getVBaseOffset().getQuantity());
    543       Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
    544       break;
    545     case VTableComponent::CK_OffsetToTop:
    546       Init = llvm::ConstantInt::get(PtrDiffTy,
    547                                     Component.getOffsetToTop().getQuantity());
    548       Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
    549       break;
    550     case VTableComponent::CK_RTTI:
    551       Init = llvm::ConstantExpr::getBitCast(RTTI, Int8PtrTy);
    552       break;
    553     case VTableComponent::CK_FunctionPointer:
    554     case VTableComponent::CK_CompleteDtorPointer:
    555     case VTableComponent::CK_DeletingDtorPointer: {
    556       GlobalDecl GD;
    557 
    558       // Get the right global decl.
    559       switch (Component.getKind()) {
    560       default:
    561         llvm_unreachable("Unexpected vtable component kind");
    562       case VTableComponent::CK_FunctionPointer:
    563         GD = Component.getFunctionDecl();
    564         break;
    565       case VTableComponent::CK_CompleteDtorPointer:
    566         GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Complete);
    567         break;
    568       case VTableComponent::CK_DeletingDtorPointer:
    569         GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Deleting);
    570         break;
    571       }
    572 
    573       if (cast<CXXMethodDecl>(GD.getDecl())->isPure()) {
    574         // We have a pure virtual member function.
    575         if (!PureVirtualFn) {
    576           llvm::FunctionType *Ty =
    577             llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
    578           StringRef PureCallName = CGM.getCXXABI().GetPureVirtualCallName();
    579           PureVirtualFn = CGM.CreateRuntimeFunction(Ty, PureCallName);
    580           PureVirtualFn = llvm::ConstantExpr::getBitCast(PureVirtualFn,
    581                                                          CGM.Int8PtrTy);
    582         }
    583         Init = PureVirtualFn;
    584       } else {
    585         // Check if we should use a thunk.
    586         if (NextVTableThunkIndex < NumVTableThunks &&
    587             VTableThunks[NextVTableThunkIndex].first == I) {
    588           const ThunkInfo &Thunk = VTableThunks[NextVTableThunkIndex].second;
    589 
    590           MaybeEmitThunkAvailableExternally(GD, Thunk);
    591           Init = CGM.GetAddrOfThunk(GD, Thunk);
    592 
    593           NextVTableThunkIndex++;
    594         } else {
    595           llvm::Type *Ty = CGM.getTypes().GetFunctionTypeForVTable(GD);
    596 
    597           Init = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true);
    598         }
    599 
    600         Init = llvm::ConstantExpr::getBitCast(Init, Int8PtrTy);
    601       }
    602       break;
    603     }
    604 
    605     case VTableComponent::CK_UnusedFunctionPointer:
    606       Init = llvm::ConstantExpr::getNullValue(Int8PtrTy);
    607       break;
    608     };
    609 
    610     Inits.push_back(Init);
    611   }
    612 
    613   llvm::ArrayType *ArrayType = llvm::ArrayType::get(Int8PtrTy, NumComponents);
    614   return llvm::ConstantArray::get(ArrayType, Inits);
    615 }
    616 
    617 llvm::GlobalVariable *CodeGenVTables::GetAddrOfVTable(const CXXRecordDecl *RD) {
    618   llvm::GlobalVariable *&VTable = VTables[RD];
    619   if (VTable)
    620     return VTable;
    621 
    622   // We may need to generate a definition for this vtable.
    623   if (ShouldEmitVTableInThisTU(RD))
    624     CGM.DeferredVTables.push_back(RD);
    625 
    626   SmallString<256> OutName;
    627   llvm::raw_svector_ostream Out(OutName);
    628   CGM.getCXXABI().getMangleContext().mangleCXXVTable(RD, Out);
    629   Out.flush();
    630   StringRef Name = OutName.str();
    631 
    632   llvm::ArrayType *ArrayType =
    633     llvm::ArrayType::get(CGM.Int8PtrTy,
    634                         VTContext.getVTableLayout(RD).getNumVTableComponents());
    635 
    636   VTable =
    637     CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType,
    638                                           llvm::GlobalValue::ExternalLinkage);
    639   VTable->setUnnamedAddr(true);
    640   return VTable;
    641 }
    642 
    643 void
    644 CodeGenVTables::EmitVTableDefinition(llvm::GlobalVariable *VTable,
    645                                      llvm::GlobalVariable::LinkageTypes Linkage,
    646                                      const CXXRecordDecl *RD) {
    647   const VTableLayout &VTLayout = VTContext.getVTableLayout(RD);
    648 
    649   // Create and set the initializer.
    650   llvm::Constant *Init =
    651     CreateVTableInitializer(RD,
    652                             VTLayout.vtable_component_begin(),
    653                             VTLayout.getNumVTableComponents(),
    654                             VTLayout.vtable_thunk_begin(),
    655                             VTLayout.getNumVTableThunks());
    656   VTable->setInitializer(Init);
    657 
    658   // Set the correct linkage.
    659   VTable->setLinkage(Linkage);
    660 
    661   // Set the right visibility.
    662   CGM.setTypeVisibility(VTable, RD, CodeGenModule::TVK_ForVTable);
    663 }
    664 
    665 llvm::GlobalVariable *
    666 CodeGenVTables::GenerateConstructionVTable(const CXXRecordDecl *RD,
    667                                       const BaseSubobject &Base,
    668                                       bool BaseIsVirtual,
    669                                    llvm::GlobalVariable::LinkageTypes Linkage,
    670                                       VTableAddressPointsMapTy& AddressPoints) {
    671   OwningPtr<VTableLayout> VTLayout(
    672     VTContext.createConstructionVTableLayout(Base.getBase(),
    673                                              Base.getBaseOffset(),
    674                                              BaseIsVirtual, RD));
    675 
    676   // Add the address points.
    677   AddressPoints = VTLayout->getAddressPoints();
    678 
    679   // Get the mangled construction vtable name.
    680   SmallString<256> OutName;
    681   llvm::raw_svector_ostream Out(OutName);
    682   CGM.getCXXABI().getMangleContext().
    683     mangleCXXCtorVTable(RD, Base.getBaseOffset().getQuantity(), Base.getBase(),
    684                         Out);
    685   Out.flush();
    686   StringRef Name = OutName.str();
    687 
    688   llvm::ArrayType *ArrayType =
    689     llvm::ArrayType::get(CGM.Int8PtrTy, VTLayout->getNumVTableComponents());
    690 
    691   // Create the variable that will hold the construction vtable.
    692   llvm::GlobalVariable *VTable =
    693     CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType, Linkage);
    694   CGM.setTypeVisibility(VTable, RD, CodeGenModule::TVK_ForConstructionVTable);
    695 
    696   // V-tables are always unnamed_addr.
    697   VTable->setUnnamedAddr(true);
    698 
    699   // Create and set the initializer.
    700   llvm::Constant *Init =
    701     CreateVTableInitializer(Base.getBase(),
    702                             VTLayout->vtable_component_begin(),
    703                             VTLayout->getNumVTableComponents(),
    704                             VTLayout->vtable_thunk_begin(),
    705                             VTLayout->getNumVTableThunks());
    706   VTable->setInitializer(Init);
    707 
    708   return VTable;
    709 }
    710 
    711 void
    712 CodeGenVTables::GenerateClassData(llvm::GlobalVariable::LinkageTypes Linkage,
    713                                   const CXXRecordDecl *RD) {
    714   llvm::GlobalVariable *VTable = GetAddrOfVTable(RD);
    715   if (VTable->hasInitializer())
    716     return;
    717 
    718   EmitVTableDefinition(VTable, Linkage, RD);
    719 
    720   if (RD->getNumVBases()) {
    721     llvm::GlobalVariable *VTT = GetAddrOfVTT(RD);
    722     EmitVTTDefinition(VTT, Linkage, RD);
    723   }
    724 
    725   // If this is the magic class __cxxabiv1::__fundamental_type_info,
    726   // we will emit the typeinfo for the fundamental types. This is the
    727   // same behaviour as GCC.
    728   const DeclContext *DC = RD->getDeclContext();
    729   if (RD->getIdentifier() &&
    730       RD->getIdentifier()->isStr("__fundamental_type_info") &&
    731       isa<NamespaceDecl>(DC) &&
    732       cast<NamespaceDecl>(DC)->getIdentifier() &&
    733       cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__cxxabiv1") &&
    734       DC->getParent()->isTranslationUnit())
    735     CGM.EmitFundamentalRTTIDescriptors();
    736 }
    737