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