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   }
 458
 459   if (UseAvailableExternallyLinkage)
 460     ThunkFn->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
 461 }
 462
 463 void CodeGenVTables::MaybeEmitThunkAvailableExternally(GlobalDecl GD,
 464                                                        const ThunkInfo &Thunk) {
 465   // We only want to do this when building with optimizations.
 466   if (!CGM.getCodeGenOpts().OptimizationLevel)
 467     return;
 468
 469   // We can't emit thunks for member functions with incomplete types.
 470   const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
 471   if (!CGM.getTypes().isFuncTypeConvertible(
 472                                 cast<FunctionType>(MD->getType().getTypePtr())))
 473     return;
 474
 475   EmitThunk(GD, Thunk, /*UseAvailableExternallyLinkage=*/true);
 476 }
 477
 478 void CodeGenVTables::EmitThunks(GlobalDecl GD)
 479 {
 480   const CXXMethodDecl *MD =
 481     cast<CXXMethodDecl>(GD.getDecl())->getCanonicalDecl();
 482
 483   // We don't need to generate thunks for the base destructor.
 484   if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() == Dtor_Base)
 485     return;
 486
 487   const VTableContext::ThunkInfoVectorTy *ThunkInfoVector =
 488     VTContext.getThunkInfo(MD);
 489   if (!ThunkInfoVector)
 490     return;
 491
 492   for (unsigned I = 0, E = ThunkInfoVector->size(); I != E; ++I)
 493     EmitThunk(GD, (*ThunkInfoVector)[I],
 494               /*UseAvailableExternallyLinkage=*/false);
 495 }
 496
 497 llvm::Constant *
 498 CodeGenVTables::CreateVTableInitializer(const CXXRecordDecl *RD,
 499                                         const VTableComponent *Components,
 500                                         unsigned NumComponents,
 501                                 const VTableLayout::VTableThunkTy *VTableThunks,
 502                                         unsigned NumVTableThunks) {
 503   SmallVector<llvm::Constant *, 64> Inits;
 504
 505   llvm::Type *Int8PtrTy = CGM.Int8PtrTy;
 506
 507   llvm::Type *PtrDiffTy =
 508     CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
 509
 510   QualType ClassType = CGM.getContext().getTagDeclType(RD);
 511   llvm::Constant *RTTI = CGM.GetAddrOfRTTIDescriptor(ClassType);
 512
 513   unsigned NextVTableThunkIndex = 0;
 514
 515   llvm::Constant *PureVirtualFn = 0, *DeletedVirtualFn = 0;
 516
 517   for (unsigned I = 0; I != NumComponents; ++I) {
 518     VTableComponent Component = Components[I];
 519
 520     llvm::Constant *Init = 0;
 521
 522     switch (Component.getKind()) {
 523     case VTableComponent::CK_VCallOffset:
 524       Init = llvm::ConstantInt::get(PtrDiffTy,
 525                                     Component.getVCallOffset().getQuantity());
 526       Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
 527       break;
 528     case VTableComponent::CK_VBaseOffset:
 529       Init = llvm::ConstantInt::get(PtrDiffTy,
 530                                     Component.getVBaseOffset().getQuantity());
 531       Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
 532       break;
 533     case VTableComponent::CK_OffsetToTop:
 534       Init = llvm::ConstantInt::get(PtrDiffTy,
 535                                     Component.getOffsetToTop().getQuantity());
 536       Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
 537       break;
 538     case VTableComponent::CK_RTTI:
 539       Init = llvm::ConstantExpr::getBitCast(RTTI, Int8PtrTy);
 540       break;
 541     case VTableComponent::CK_FunctionPointer:
 542     case VTableComponent::CK_CompleteDtorPointer:
 543     case VTableComponent::CK_DeletingDtorPointer: {
 544       GlobalDecl GD;
 545
 546       // Get the right global decl.
 547       switch (Component.getKind()) {
 548       default:
 549         llvm_unreachable("Unexpected vtable component kind");
 550       case VTableComponent::CK_FunctionPointer:
 551         GD = Component.getFunctionDecl();
 552         break;
 553       case VTableComponent::CK_CompleteDtorPointer:
 554         GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Complete);
 555         break;
 556       case VTableComponent::CK_DeletingDtorPointer:
 557         GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Deleting);
 558         break;
 559       }
 560
 561       if (cast<CXXMethodDecl>(GD.getDecl())->isPure()) {
 562         // We have a pure virtual member function.
 563         if (!PureVirtualFn) {
 564           llvm::FunctionType *Ty =
 565             llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
 566           StringRef PureCallName = CGM.getCXXABI().GetPureVirtualCallName();
 567           PureVirtualFn = CGM.CreateRuntimeFunction(Ty, PureCallName);
 568           PureVirtualFn = llvm::ConstantExpr::getBitCast(PureVirtualFn,
 569                                                          CGM.Int8PtrTy);
 570         }
 571         Init = PureVirtualFn;
 572       } else if (cast<CXXMethodDecl>(GD.getDecl())->isDeleted()) {
 573         if (!DeletedVirtualFn) {
 574           llvm::FunctionType *Ty =
 575             llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
 576           StringRef DeletedCallName =
 577             CGM.getCXXABI().GetDeletedVirtualCallName();
 578           DeletedVirtualFn = CGM.CreateRuntimeFunction(Ty, DeletedCallName);
 579           DeletedVirtualFn = llvm::ConstantExpr::getBitCast(DeletedVirtualFn,
 580                                                          CGM.Int8PtrTy);
 581         }
 582         Init = DeletedVirtualFn;
 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           MaybeEmitThunkAvailableExternally(GD, Thunk);
 590           Init = CGM.GetAddrOfThunk(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   // Queue up this v-table for possible deferred emission.
 622   CGM.addDeferredVTable(RD);
 623
 624   SmallString<256> OutName;
 625   llvm::raw_svector_ostream Out(OutName);
 626   CGM.getCXXABI().getMangleContext().mangleCXXVTable(RD, Out);
 627   Out.flush();
 628   StringRef Name = OutName.str();
 629
 630   llvm::ArrayType *ArrayType =
 631     llvm::ArrayType::get(CGM.Int8PtrTy,
 632                         VTContext.getVTableLayout(RD).getNumVTableComponents());
 633
 634   VTable =
 635     CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType,
 636                                           llvm::GlobalValue::ExternalLinkage);
 637   VTable->setUnnamedAddr(true);
 638   return VTable;
 639 }
 640
 641 void
 642 CodeGenVTables::EmitVTableDefinition(llvm::GlobalVariable *VTable,
 643                                      llvm::GlobalVariable::LinkageTypes Linkage,
 644                                      const CXXRecordDecl *RD) {
 645   const VTableLayout &VTLayout = VTContext.getVTableLayout(RD);
 646
 647   // Create and set the initializer.
 648   llvm::Constant *Init =
 649     CreateVTableInitializer(RD,
 650                             VTLayout.vtable_component_begin(),
 651                             VTLayout.getNumVTableComponents(),
 652                             VTLayout.vtable_thunk_begin(),
 653                             VTLayout.getNumVTableThunks());
 654   VTable->setInitializer(Init);
 655
 656   // Set the correct linkage.
 657   VTable->setLinkage(Linkage);
 658
 659   // Set the right visibility.
 660   CGM.setTypeVisibility(VTable, RD, CodeGenModule::TVK_ForVTable);
 661 }
 662
 663 llvm::GlobalVariable *
 664 CodeGenVTables::GenerateConstructionVTable(const CXXRecordDecl *RD,
 665                                       const BaseSubobject &Base,
 666                                       bool BaseIsVirtual,
 667                                    llvm::GlobalVariable::LinkageTypes Linkage,
 668                                       VTableAddressPointsMapTy& AddressPoints) {
 669   OwningPtr<VTableLayout> VTLayout(
 670     VTContext.createConstructionVTableLayout(Base.getBase(),
 671                                              Base.getBaseOffset(),
 672                                              BaseIsVirtual, RD));
 673
 674   // Add the address points.
 675   AddressPoints = VTLayout->getAddressPoints();
 676
 677   // Get the mangled construction vtable name.
 678   SmallString<256> OutName;
 679   llvm::raw_svector_ostream Out(OutName);
 680   CGM.getCXXABI().getMangleContext().
 681     mangleCXXCtorVTable(RD, Base.getBaseOffset().getQuantity(), Base.getBase(),
 682                         Out);
 683   Out.flush();
 684   StringRef Name = OutName.str();
 685
 686   llvm::ArrayType *ArrayType =
 687     llvm::ArrayType::get(CGM.Int8PtrTy, VTLayout->getNumVTableComponents());
 688
 689   // Construction vtable symbols are not part of the Itanium ABI, so we cannot
 690   // guarantee that they actually will be available externally. Instead, when
 691   // emitting an available_externally VTT, we provide references to an internal
 692   // linkage construction vtable. The ABI only requires complete-object vtables
 693   // to be the same for all instances of a type, not construction vtables.
 694   if (Linkage == llvm::GlobalVariable::AvailableExternallyLinkage)
 695     Linkage = llvm::GlobalVariable::InternalLinkage;
 696
 697   // Create the variable that will hold the construction vtable.
 698   llvm::GlobalVariable *VTable =
 699     CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType, Linkage);
 700   CGM.setTypeVisibility(VTable, RD, CodeGenModule::TVK_ForConstructionVTable);
 701
 702   // V-tables are always unnamed_addr.
 703   VTable->setUnnamedAddr(true);
 704
 705   // Create and set the initializer.
 706   llvm::Constant *Init =
 707     CreateVTableInitializer(Base.getBase(),
 708                             VTLayout->vtable_component_begin(),
 709                             VTLayout->getNumVTableComponents(),
 710                             VTLayout->vtable_thunk_begin(),
 711                             VTLayout->getNumVTableThunks());
 712   VTable->setInitializer(Init);
 713
 714   return VTable;
 715 }
 716
 717 /// Compute the required linkage of the v-table for the given class.
 718 ///
 719 /// Note that we only call this at the end of the translation unit.
 720 llvm::GlobalVariable::LinkageTypes
 721 CodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) {
 722   if (RD->getLinkage() != ExternalLinkage)
 723     return llvm::GlobalVariable::InternalLinkage;
 724
 725   // We're at the end of the translation unit, so the current key
 726   // function is fully correct.
 727   if (const CXXMethodDecl *keyFunction = Context.getCurrentKeyFunction(RD)) {
 728     // If this class has a key function, use that to determine the
 729     // linkage of the vtable.
 730     const FunctionDecl *def = 0;
 731     if (keyFunction->hasBody(def))
 732       keyFunction = cast<CXXMethodDecl>(def);
 733
 734     switch (keyFunction->getTemplateSpecializationKind()) {
 735       case TSK_Undeclared:
 736       case TSK_ExplicitSpecialization:
 737         // When compiling with optimizations turned on, we emit all vtables,
 738         // even if the key function is not defined in the current translation
 739         // unit. If this is the case, use available_externally linkage.
 740         if (!def && CodeGenOpts.OptimizationLevel)
 741           return llvm::GlobalVariable::AvailableExternallyLinkage;
 742
 743         if (keyFunction->isInlined())
 744           return !Context.getLangOpts().AppleKext ?
 745                    llvm::GlobalVariable::LinkOnceODRLinkage :
 746                    llvm::Function::InternalLinkage;
 747
 748         return llvm::GlobalVariable::ExternalLinkage;
 749
 750       case TSK_ImplicitInstantiation:
 751         return !Context.getLangOpts().AppleKext ?
 752                  llvm::GlobalVariable::LinkOnceODRLinkage :
 753                  llvm::Function::InternalLinkage;
 754
 755       case TSK_ExplicitInstantiationDefinition:
 756         return !Context.getLangOpts().AppleKext ?
 757                  llvm::GlobalVariable::WeakODRLinkage :
 758                  llvm::Function::InternalLinkage;
 759
 760       case TSK_ExplicitInstantiationDeclaration:
 761         return !Context.getLangOpts().AppleKext ?
 762                  llvm::GlobalVariable::AvailableExternallyLinkage :
 763                  llvm::Function::InternalLinkage;
 764     }
 765   }
 766
 767   // -fapple-kext mode does not support weak linkage, so we must use
 768   // internal linkage.
 769   if (Context.getLangOpts().AppleKext)
 770     return llvm::Function::InternalLinkage;
 771
 772   switch (RD->getTemplateSpecializationKind()) {
 773   case TSK_Undeclared:
 774   case TSK_ExplicitSpecialization:
 775   case TSK_ImplicitInstantiation:
 776     return llvm::GlobalVariable::LinkOnceODRLinkage;
 777
 778   case TSK_ExplicitInstantiationDeclaration:
 779     return llvm::GlobalVariable::AvailableExternallyLinkage;
 780
 781   case TSK_ExplicitInstantiationDefinition:
 782       return llvm::GlobalVariable::WeakODRLinkage;
 783   }
 784
 785   llvm_unreachable("Invalid TemplateSpecializationKind!");
 786 }
 787
 788 /// This is a callback from Sema to tell us that it believes that a
 789 /// particular v-table is required to be emitted in this translation
 790 /// unit.
 791 ///
 792 /// The reason we don't simply trust this callback is because Sema
 793 /// will happily report that something is used even when it's used
 794 /// only in code that we don't actually have to emit.
 795 ///
 796 /// \param isRequired - if true, the v-table is mandatory, e.g.
 797 ///   because the translation unit defines the key function
 798 void CodeGenModule::EmitVTable(CXXRecordDecl *theClass, bool isRequired) {
 799   if (!isRequired) return;
 800
 801   VTables.GenerateClassData(theClass);
 802 }
 803
 804 void
 805 CodeGenVTables::GenerateClassData(const CXXRecordDecl *RD) {
 806   // First off, check whether we've already emitted the v-table and
 807   // associated stuff.
 808   llvm::GlobalVariable *VTable = GetAddrOfVTable(RD);
 809   if (VTable->hasInitializer())
 810     return;
 811
 812   llvm::GlobalVariable::LinkageTypes Linkage = CGM.getVTableLinkage(RD);
 813   EmitVTableDefinition(VTable, Linkage, RD);
 814
 815   if (RD->getNumVBases()) {
 816     if (!CGM.getTarget().getCXXABI().isMicrosoft()) {
 817       llvm::GlobalVariable *VTT = GetAddrOfVTT(RD);
 818       EmitVTTDefinition(VTT, Linkage, RD);
 819     } else {
 820       // FIXME: Emit vbtables here.
 821     }
 822   }
 823
 824   // If this is the magic class __cxxabiv1::__fundamental_type_info,
 825   // we will emit the typeinfo for the fundamental types. This is the
 826   // same behaviour as GCC.
 827   const DeclContext *DC = RD->getDeclContext();
 828   if (RD->getIdentifier() &&
 829       RD->getIdentifier()->isStr("__fundamental_type_info") &&
 830       isa<NamespaceDecl>(DC) &&
 831       cast<NamespaceDecl>(DC)->getIdentifier() &&
 832       cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__cxxabiv1") &&
 833       DC->getParent()->isTranslationUnit())
 834     CGM.EmitFundamentalRTTIDescriptors();
 835 }
 836
 837 /// At this point in the translation unit, does it appear that can we
 838 /// rely on the vtable being defined elsewhere in the program?
 839 ///
 840 /// The response is really only definitive when called at the end of
 841 /// the translation unit.
 842 ///
 843 /// The only semantic restriction here is that the object file should
 844 /// not contain a v-table definition when that v-table is defined
 845 /// strongly elsewhere.  Otherwise, we'd just like to avoid emitting
 846 /// v-tables when unnecessary.
 847 bool CodeGenVTables::isVTableExternal(const CXXRecordDecl *RD) {
 848   assert(RD->isDynamicClass() && "Non dynamic classes have no VTable.");
 849
 850   // If we have an explicit instantiation declaration (and not a
 851   // definition), the v-table is defined elsewhere.
 852   TemplateSpecializationKind TSK = RD->getTemplateSpecializationKind();
 853   if (TSK == TSK_ExplicitInstantiationDeclaration)
 854     return true;
 855
 856   // Otherwise, if the class is an instantiated template, the
 857   // v-table must be defined here.
 858   if (TSK == TSK_ImplicitInstantiation ||
 859       TSK == TSK_ExplicitInstantiationDefinition)
 860     return false;
 861
 862   // Otherwise, if the class doesn't have a key function (possibly
 863   // anymore), the v-table must be defined here.
 864   const CXXMethodDecl *keyFunction = CGM.getContext().getCurrentKeyFunction(RD);
 865   if (!keyFunction)
 866     return false;
 867
 868   // Otherwise, if we don't have a definition of the key function, the
 869   // v-table must be defined somewhere else.
 870   return !keyFunction->hasBody();
 871 }
 872
 873 /// Given that we're currently at the end of the translation unit, and
 874 /// we've emitted a reference to the v-table for this class, should
 875 /// we define that v-table?
 876 static bool shouldEmitVTableAtEndOfTranslationUnit(CodeGenModule &CGM,
 877                                                    const CXXRecordDecl *RD) {
 878   // If we're building with optimization, we always emit v-tables
 879   // since that allows for virtual function calls to be devirtualized.
 880   // If the v-table is defined strongly elsewhere, this definition
 881   // will be emitted available_externally.
 882   //
 883   // However, we don't want to do this in -fapple-kext mode, because
 884   // kext mode does not permit devirtualization.
 885   if (CGM.getCodeGenOpts().OptimizationLevel && !CGM.getLangOpts().AppleKext)
 886     return true;
 887
 888   return !CGM.getVTables().isVTableExternal(RD);
 889 }
 890
 891 /// Given that at some point we emitted a reference to one or more
 892 /// v-tables, and that we are now at the end of the translation unit,
 893 /// decide whether we should emit them.
 894 void CodeGenModule::EmitDeferredVTables() {
 895 #ifndef NDEBUG
 896   // Remember the size of DeferredVTables, because we're going to assume
 897   // that this entire operation doesn't modify it.
 898   size_t savedSize = DeferredVTables.size();
 899 #endif
 900
 901   typedef std::vector<const CXXRecordDecl *>::const_iterator const_iterator;
 902   for (const_iterator i = DeferredVTables.begin(),
 903                       e = DeferredVTables.end(); i != e; ++i) {
 904     const CXXRecordDecl *RD = *i;
 905     if (shouldEmitVTableAtEndOfTranslationUnit(*this, RD))
 906       VTables.GenerateClassData(RD);
 907   }
 908
 909   assert(savedSize == DeferredVTables.size() &&
 910          "deferred extra v-tables during v-table emission?");
 911   DeferredVTables.clear();
 912 }