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.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().arrangeFunctionCall(ResultType, CallArgs, FPT->getExtInfo(),
 360                                        RequiredArgs::forPrototypePlus(FPT, 1));
 361   assert(CallFnInfo.getRegParm() == FnInfo.getRegParm() &&
 362          CallFnInfo.isNoReturn() == FnInfo.isNoReturn() &&
 363          CallFnInfo.getCallingConvention() == FnInfo.getCallingConvention());
 364   assert(similar(CallFnInfo.getReturnInfo(), CallFnInfo.getReturnType(),
 365                  FnInfo.getReturnInfo(), FnInfo.getReturnType()));
 366   assert(CallFnInfo.arg_size() == FnInfo.arg_size());
 367   for (unsigned i = 0, e = FnInfo.arg_size(); i != e; ++i)
 368     assert(similar(CallFnInfo.arg_begin()[i].info,
 369                    CallFnInfo.arg_begin()[i].type,
 370                    FnInfo.arg_begin()[i].info, FnInfo.arg_begin()[i].type));
 371 #endif
 372
 373   // Determine whether we have a return value slot to use.
 374   ReturnValueSlot Slot;
 375   if (!ResultType->isVoidType() &&
 376       FnInfo.getReturnInfo().getKind() == ABIArgInfo::Indirect &&
 377       hasAggregateLLVMType(CurFnInfo->getReturnType()))
 378     Slot = ReturnValueSlot(ReturnValue, ResultType.isVolatileQualified());
 379
 380   // Now emit our call.
 381   RValue RV = EmitCall(FnInfo, Callee, Slot, CallArgs, MD);
 382
 383   if (!Thunk.Return.isEmpty())
 384     RV = PerformReturnAdjustment(*this, ResultType, RV, Thunk);
 385
 386   if (!ResultType->isVoidType() && Slot.isNull())
 387     CGM.getCXXABI().EmitReturnFromThunk(*this, RV, ResultType);
 388
 389   FinishFunction();
 390
 391   // Set the right linkage.
 392   CGM.setFunctionLinkage(MD, Fn);
 393
 394   // Set the right visibility.
 395   setThunkVisibility(CGM, MD, Thunk, Fn);
 396 }
 397
 398 void CodeGenVTables::EmitThunk(GlobalDecl GD, const ThunkInfo &Thunk,
 399                                bool UseAvailableExternallyLinkage)
 400 {
 401   const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeGlobalDeclaration(GD);
 402
 403   // FIXME: re-use FnInfo in this computation.
 404   llvm::Constant *Entry = CGM.GetAddrOfThunk(GD, Thunk);
 405
 406   // Strip off a bitcast if we got one back.
 407   if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
 408     assert(CE->getOpcode() == llvm::Instruction::BitCast);
 409     Entry = CE->getOperand(0);
 410   }
 411
 412   // There's already a declaration with the same name, check if it has the same
 413   // type or if we need to replace it.
 414   if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() !=
 415       CGM.getTypes().GetFunctionTypeForVTable(GD)) {
 416     llvm::GlobalValue *OldThunkFn = cast<llvm::GlobalValue>(Entry);
 417
 418     // If the types mismatch then we have to rewrite the definition.
 419     assert(OldThunkFn->isDeclaration() &&
 420            "Shouldn't replace non-declaration");
 421
 422     // Remove the name from the old thunk function and get a new thunk.
 423     OldThunkFn->setName(StringRef());
 424     Entry = CGM.GetAddrOfThunk(GD, Thunk);
 425
 426     // If needed, replace the old thunk with a bitcast.
 427     if (!OldThunkFn->use_empty()) {
 428       llvm::Constant *NewPtrForOldDecl =
 429         llvm::ConstantExpr::getBitCast(Entry, OldThunkFn->getType());
 430       OldThunkFn->replaceAllUsesWith(NewPtrForOldDecl);
 431     }
 432
 433     // Remove the old thunk.
 434     OldThunkFn->eraseFromParent();
 435   }
 436
 437   llvm::Function *ThunkFn = cast<llvm::Function>(Entry);
 438
 439   if (!ThunkFn->isDeclaration()) {
 440     if (UseAvailableExternallyLinkage) {
 441       // There is already a thunk emitted for this function, do nothing.
 442       return;
 443     }
 444
 445     // If a function has a body, it should have available_externally linkage.
 446     assert(ThunkFn->hasAvailableExternallyLinkage() &&
 447            "Function should have available_externally linkage!");
 448
 449     // Change the linkage.
 450     CGM.setFunctionLinkage(cast<CXXMethodDecl>(GD.getDecl()), ThunkFn);
 451     return;
 452   }
 453
 454   if (ThunkFn->isVarArg()) {
 455     // Varargs thunks are special; we can't just generate a call because
 456     // we can't copy the varargs.  Our implementation is rather
 457     // expensive/sucky at the moment, so don't generate the thunk unless
 458     // we have to.
 459     // FIXME: Do something better here; GenerateVarArgsThunk is extremely ugly.
 460     if (!UseAvailableExternallyLinkage)
 461       CodeGenFunction(CGM).GenerateVarArgsThunk(ThunkFn, FnInfo, GD, Thunk);
 462   } else {
 463     // Normal thunk body generation.
 464     CodeGenFunction(CGM).GenerateThunk(ThunkFn, FnInfo, GD, Thunk);
 465   }
 466
 467   if (UseAvailableExternallyLinkage)
 468     ThunkFn->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
 469 }
 470
 471 void CodeGenVTables::MaybeEmitThunkAvailableExternally(GlobalDecl GD,
 472                                                        const ThunkInfo &Thunk) {
 473   // We only want to do this when building with optimizations.
 474   if (!CGM.getCodeGenOpts().OptimizationLevel)
 475     return;
 476
 477   // We can't emit thunks for member functions with incomplete types.
 478   const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
 479   if (!CGM.getTypes().isFuncTypeConvertible(
 480                                 cast<FunctionType>(MD->getType().getTypePtr())))
 481     return;
 482
 483   EmitThunk(GD, Thunk, /*UseAvailableExternallyLinkage=*/true);
 484 }
 485
 486 void CodeGenVTables::EmitThunks(GlobalDecl GD)
 487 {
 488   const CXXMethodDecl *MD =
 489     cast<CXXMethodDecl>(GD.getDecl())->getCanonicalDecl();
 490
 491   // We don't need to generate thunks for the base destructor.
 492   if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() == Dtor_Base)
 493     return;
 494
 495   const VTableContext::ThunkInfoVectorTy *ThunkInfoVector =
 496     VTContext.getThunkInfo(MD);
 497   if (!ThunkInfoVector)
 498     return;
 499
 500   for (unsigned I = 0, E = ThunkInfoVector->size(); I != E; ++I)
 501     EmitThunk(GD, (*ThunkInfoVector)[I],
 502               /*UseAvailableExternallyLinkage=*/false);
 503 }
 504
 505 llvm::Constant *
 506 CodeGenVTables::CreateVTableInitializer(const CXXRecordDecl *RD,
 507                                         const VTableComponent *Components,
 508                                         unsigned NumComponents,
 509                                 const VTableLayout::VTableThunkTy *VTableThunks,
 510                                         unsigned NumVTableThunks) {
 511   SmallVector<llvm::Constant *, 64> Inits;
 512
 513   llvm::Type *Int8PtrTy = CGM.Int8PtrTy;
 514
 515   llvm::Type *PtrDiffTy =
 516     CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
 517
 518   QualType ClassType = CGM.getContext().getTagDeclType(RD);
 519   llvm::Constant *RTTI = CGM.GetAddrOfRTTIDescriptor(ClassType);
 520
 521   unsigned NextVTableThunkIndex = 0;
 522
 523   llvm::Constant* PureVirtualFn = 0;
 524
 525   for (unsigned I = 0; I != NumComponents; ++I) {
 526     VTableComponent Component = Components[I];
 527
 528     llvm::Constant *Init = 0;
 529
 530     switch (Component.getKind()) {
 531     case VTableComponent::CK_VCallOffset:
 532       Init = llvm::ConstantInt::get(PtrDiffTy,
 533                                     Component.getVCallOffset().getQuantity());
 534       Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
 535       break;
 536     case VTableComponent::CK_VBaseOffset:
 537       Init = llvm::ConstantInt::get(PtrDiffTy,
 538                                     Component.getVBaseOffset().getQuantity());
 539       Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
 540       break;
 541     case VTableComponent::CK_OffsetToTop:
 542       Init = llvm::ConstantInt::get(PtrDiffTy,
 543                                     Component.getOffsetToTop().getQuantity());
 544       Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
 545       break;
 546     case VTableComponent::CK_RTTI:
 547       Init = llvm::ConstantExpr::getBitCast(RTTI, Int8PtrTy);
 548       break;
 549     case VTableComponent::CK_FunctionPointer:
 550     case VTableComponent::CK_CompleteDtorPointer:
 551     case VTableComponent::CK_DeletingDtorPointer: {
 552       GlobalDecl GD;
 553
 554       // Get the right global decl.
 555       switch (Component.getKind()) {
 556       default:
 557         llvm_unreachable("Unexpected vtable component kind");
 558       case VTableComponent::CK_FunctionPointer:
 559         GD = Component.getFunctionDecl();
 560         break;
 561       case VTableComponent::CK_CompleteDtorPointer:
 562         GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Complete);
 563         break;
 564       case VTableComponent::CK_DeletingDtorPointer:
 565         GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Deleting);
 566         break;
 567       }
 568
 569       if (cast<CXXMethodDecl>(GD.getDecl())->isPure()) {
 570         // We have a pure virtual member function.
 571         if (!PureVirtualFn) {
 572           llvm::FunctionType *Ty =
 573             llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
 574           PureVirtualFn =
 575             CGM.CreateRuntimeFunction(Ty, "__cxa_pure_virtual");
 576           PureVirtualFn = llvm::ConstantExpr::getBitCast(PureVirtualFn,
 577                                                          Int8PtrTy);
 578         }
 579
 580         Init = PureVirtualFn;
 581       } else {
 582         // Check if we should use a thunk.
 583         if (NextVTableThunkIndex < NumVTableThunks &&
 584             VTableThunks[NextVTableThunkIndex].first == I) {
 585           const ThunkInfo &Thunk = VTableThunks[NextVTableThunkIndex].second;
 586
 587           MaybeEmitThunkAvailableExternally(GD, Thunk);
 588           Init = CGM.GetAddrOfThunk(GD, Thunk);
 589
 590           NextVTableThunkIndex++;
 591         } else {
 592           llvm::Type *Ty = CGM.getTypes().GetFunctionTypeForVTable(GD);
 593
 594           Init = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true);
 595         }
 596
 597         Init = llvm::ConstantExpr::getBitCast(Init, Int8PtrTy);
 598       }
 599       break;
 600     }
 601
 602     case VTableComponent::CK_UnusedFunctionPointer:
 603       Init = llvm::ConstantExpr::getNullValue(Int8PtrTy);
 604       break;
 605     };
 606
 607     Inits.push_back(Init);
 608   }
 609
 610   llvm::ArrayType *ArrayType = llvm::ArrayType::get(Int8PtrTy, NumComponents);
 611   return llvm::ConstantArray::get(ArrayType, Inits);
 612 }
 613
 614 llvm::GlobalVariable *CodeGenVTables::GetAddrOfVTable(const CXXRecordDecl *RD) {
 615   llvm::GlobalVariable *&VTable = VTables[RD];
 616   if (VTable)
 617     return VTable;
 618
 619   // We may need to generate a definition for this vtable.
 620   if (ShouldEmitVTableInThisTU(RD))
 621     CGM.DeferredVTables.push_back(RD);
 622
 623   SmallString<256> OutName;
 624   llvm::raw_svector_ostream Out(OutName);
 625   CGM.getCXXABI().getMangleContext().mangleCXXVTable(RD, Out);
 626   Out.flush();
 627   StringRef Name = OutName.str();
 628
 629   llvm::ArrayType *ArrayType =
 630     llvm::ArrayType::get(CGM.Int8PtrTy,
 631                         VTContext.getVTableLayout(RD).getNumVTableComponents());
 632
 633   VTable =
 634     CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType,
 635                                           llvm::GlobalValue::ExternalLinkage);
 636   VTable->setUnnamedAddr(true);
 637   return VTable;
 638 }
 639
 640 void
 641 CodeGenVTables::EmitVTableDefinition(llvm::GlobalVariable *VTable,
 642                                      llvm::GlobalVariable::LinkageTypes Linkage,
 643                                      const CXXRecordDecl *RD) {
 644   const VTableLayout &VTLayout = VTContext.getVTableLayout(RD);
 645
 646   // Create and set the initializer.
 647   llvm::Constant *Init =
 648     CreateVTableInitializer(RD,
 649                             VTLayout.vtable_component_begin(),
 650                             VTLayout.getNumVTableComponents(),
 651                             VTLayout.vtable_thunk_begin(),
 652                             VTLayout.getNumVTableThunks());
 653   VTable->setInitializer(Init);
 654
 655   // Set the correct linkage.
 656   VTable->setLinkage(Linkage);
 657
 658   // Set the right visibility.
 659   CGM.setTypeVisibility(VTable, RD, CodeGenModule::TVK_ForVTable);
 660 }
 661
 662 llvm::GlobalVariable *
 663 CodeGenVTables::GenerateConstructionVTable(const CXXRecordDecl *RD,
 664                                       const BaseSubobject &Base,
 665                                       bool BaseIsVirtual,
 666                                    llvm::GlobalVariable::LinkageTypes Linkage,
 667                                       VTableAddressPointsMapTy& AddressPoints) {
 668   OwningPtr<VTableLayout> VTLayout(
 669     VTContext.createConstructionVTableLayout(Base.getBase(),
 670                                              Base.getBaseOffset(),
 671                                              BaseIsVirtual, RD));
 672
 673   // Add the address points.
 674   AddressPoints = VTLayout->getAddressPoints();
 675
 676   // Get the mangled construction vtable name.
 677   SmallString<256> OutName;
 678   llvm::raw_svector_ostream Out(OutName);
 679   CGM.getCXXABI().getMangleContext().
 680     mangleCXXCtorVTable(RD, Base.getBaseOffset().getQuantity(), Base.getBase(),
 681                         Out);
 682   Out.flush();
 683   StringRef Name = OutName.str();
 684
 685   llvm::ArrayType *ArrayType =
 686     llvm::ArrayType::get(CGM.Int8PtrTy, VTLayout->getNumVTableComponents());
 687
 688   // Create the variable that will hold the construction vtable.
 689   llvm::GlobalVariable *VTable =
 690     CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType, Linkage);
 691   CGM.setTypeVisibility(VTable, RD, CodeGenModule::TVK_ForConstructionVTable);
 692
 693   // V-tables are always unnamed_addr.
 694   VTable->setUnnamedAddr(true);
 695
 696   // Create and set the initializer.
 697   llvm::Constant *Init =
 698     CreateVTableInitializer(Base.getBase(),
 699                             VTLayout->vtable_component_begin(),
 700                             VTLayout->getNumVTableComponents(),
 701                             VTLayout->vtable_thunk_begin(),
 702                             VTLayout->getNumVTableThunks());
 703   VTable->setInitializer(Init);
 704
 705   return VTable;
 706 }
 707
 708 void
 709 CodeGenVTables::GenerateClassData(llvm::GlobalVariable::LinkageTypes Linkage,
 710                                   const CXXRecordDecl *RD) {
 711   llvm::GlobalVariable *VTable = GetAddrOfVTable(RD);
 712   if (VTable->hasInitializer())
 713     return;
 714
 715   EmitVTableDefinition(VTable, Linkage, RD);
 716
 717   if (RD->getNumVBases()) {
 718     llvm::GlobalVariable *VTT = GetAddrOfVTT(RD);
 719     EmitVTTDefinition(VTT, Linkage, RD);
 720   }
 721
 722   // If this is the magic class __cxxabiv1::__fundamental_type_info,
 723   // we will emit the typeinfo for the fundamental types. This is the
 724   // same behaviour as GCC.
 725   const DeclContext *DC = RD->getDeclContext();
 726   if (RD->getIdentifier() &&
 727       RD->getIdentifier()->isStr("__fundamental_type_info") &&
 728       isa<NamespaceDecl>(DC) &&
 729       cast<NamespaceDecl>(DC)->getIdentifier() &&
 730       cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__cxxabiv1") &&
 731       DC->getParent()->isTranslationUnit())
 732     CGM.EmitFundamentalRTTIDescriptors();
 733 }