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/CodeGen/CGFunctionInfo.h"
  20 #include "clang/Frontend/CodeGenOptions.h"
  21 #include "llvm/ADT/DenseSet.h"
  22 #include "llvm/ADT/SetVector.h"
  23 #include "llvm/Support/Compiler.h"
  24 #include "llvm/Support/Format.h"
  25 #include "llvm/Transforms/Utils/Cloning.h"
  26 #include <algorithm>
  27 #include <cstdio>
  28
  29 using namespace clang;
  30 using namespace CodeGen;
  31
  32 CodeGenVTables::CodeGenVTables(CodeGenModule &CGM)
  33     : CGM(CGM), VTContext(CGM.getContext().getVTableContext()) {}
  34
  35 llvm::Constant *CodeGenModule::GetAddrOfThunk(GlobalDecl GD,
  36                                               const ThunkInfo &Thunk) {
  37   const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
  38
  39   // Compute the mangled name.
  40   SmallString<256> Name;
  41   llvm::raw_svector_ostream Out(Name);
  42   if (const CXXDestructorDecl* DD = dyn_cast<CXXDestructorDecl>(MD))
  43     getCXXABI().getMangleContext().mangleCXXDtorThunk(DD, GD.getDtorType(),
  44                                                       Thunk.This, Out);
  45   else
  46     getCXXABI().getMangleContext().mangleThunk(MD, Thunk, Out);
  47
  48   llvm::Type *Ty = getTypes().GetFunctionTypeForVTable(GD);
  49   return GetOrCreateLLVMFunction(Name, Ty, GD, /*ForVTable=*/true,
  50                                  /*DontDefer=*/true, /*IsThunk=*/true);
  51 }
  52
  53 static void setThunkVisibility(CodeGenModule &CGM, const CXXMethodDecl *MD,
  54                                const ThunkInfo &Thunk, llvm::Function *Fn) {
  55   CGM.setGlobalVisibility(Fn, MD);
  56 }
  57
  58 static void setThunkProperties(CodeGenModule &CGM, const ThunkInfo &Thunk,
  59                                llvm::Function *ThunkFn, bool ForVTable,
  60                                GlobalDecl GD) {
  61   CGM.setFunctionLinkage(GD, ThunkFn);
  62   CGM.getCXXABI().setThunkLinkage(ThunkFn, ForVTable, GD,
  63                                   !Thunk.Return.isEmpty());
  64
  65   // Set the right visibility.
  66   const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
  67   setThunkVisibility(CGM, MD, Thunk, ThunkFn);
  68
  69   if (CGM.supportsCOMDAT() && ThunkFn->isWeakForLinker())
  70     ThunkFn->setComdat(CGM.getModule().getOrInsertComdat(ThunkFn->getName()));
  71 }
  72
  73 #ifndef NDEBUG
  74 static bool similar(const ABIArgInfo &infoL, CanQualType typeL,
  75                     const ABIArgInfo &infoR, CanQualType typeR) {
  76   return (infoL.getKind() == infoR.getKind() &&
  77           (typeL == typeR ||
  78            (isa<PointerType>(typeL) && isa<PointerType>(typeR)) ||
  79            (isa<ReferenceType>(typeL) && isa<ReferenceType>(typeR))));
  80 }
  81 #endif
  82
  83 static RValue PerformReturnAdjustment(CodeGenFunction &CGF,
  84                                       QualType ResultType, RValue RV,
  85                                       const ThunkInfo &Thunk) {
  86   // Emit the return adjustment.
  87   bool NullCheckValue = !ResultType->isReferenceType();
  88
  89   llvm::BasicBlock *AdjustNull = nullptr;
  90   llvm::BasicBlock *AdjustNotNull = nullptr;
  91   llvm::BasicBlock *AdjustEnd = nullptr;
  92
  93   llvm::Value *ReturnValue = RV.getScalarVal();
  94
  95   if (NullCheckValue) {
  96     AdjustNull = CGF.createBasicBlock("adjust.null");
  97     AdjustNotNull = CGF.createBasicBlock("adjust.notnull");
  98     AdjustEnd = CGF.createBasicBlock("adjust.end");
  99
 100     llvm::Value *IsNull = CGF.Builder.CreateIsNull(ReturnValue);
 101     CGF.Builder.CreateCondBr(IsNull, AdjustNull, AdjustNotNull);
 102     CGF.EmitBlock(AdjustNotNull);
 103   }
 104
 105   auto ClassDecl = ResultType->getPointeeType()->getAsCXXRecordDecl();
 106   auto ClassAlign = CGF.CGM.getClassPointerAlignment(ClassDecl);
 107   ReturnValue = CGF.CGM.getCXXABI().performReturnAdjustment(CGF,
 108                                             Address(ReturnValue, ClassAlign),
 109                                             Thunk.Return);
 110
 111   if (NullCheckValue) {
 112     CGF.Builder.CreateBr(AdjustEnd);
 113     CGF.EmitBlock(AdjustNull);
 114     CGF.Builder.CreateBr(AdjustEnd);
 115     CGF.EmitBlock(AdjustEnd);
 116
 117     llvm::PHINode *PHI = CGF.Builder.CreatePHI(ReturnValue->getType(), 2);
 118     PHI->addIncoming(ReturnValue, AdjustNotNull);
 119     PHI->addIncoming(llvm::Constant::getNullValue(ReturnValue->getType()),
 120                      AdjustNull);
 121     ReturnValue = PHI;
 122   }
 123
 124   return RValue::get(ReturnValue);
 125 }
 126
 127 // This function does roughly the same thing as GenerateThunk, but in a
 128 // very different way, so that va_start and va_end work correctly.
 129 // FIXME: This function assumes "this" is the first non-sret LLVM argument of
 130 //        a function, and that there is an alloca built in the entry block
 131 //        for all accesses to "this".
 132 // FIXME: This function assumes there is only one "ret" statement per function.
 133 // FIXME: Cloning isn't correct in the presence of indirect goto!
 134 // FIXME: This implementation of thunks bloats codesize by duplicating the
 135 //        function definition.  There are alternatives:
 136 //        1. Add some sort of stub support to LLVM for cases where we can
 137 //           do a this adjustment, then a sibcall.
 138 //        2. We could transform the definition to take a va_list instead of an
 139 //           actual variable argument list, then have the thunks (including a
 140 //           no-op thunk for the regular definition) call va_start/va_end.
 141 //           There's a bit of per-call overhead for this solution, but it's
 142 //           better for codesize if the definition is long.
 143 llvm::Function *
 144 CodeGenFunction::GenerateVarArgsThunk(llvm::Function *Fn,
 145                                       const CGFunctionInfo &FnInfo,
 146                                       GlobalDecl GD, const ThunkInfo &Thunk) {
 147   const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
 148   const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
 149   QualType ResultType = FPT->getReturnType();
 150
 151   // Get the original function
 152   assert(FnInfo.isVariadic());
 153   llvm::Type *Ty = CGM.getTypes().GetFunctionType(FnInfo);
 154   llvm::Value *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true);
 155   llvm::Function *BaseFn = cast<llvm::Function>(Callee);
 156
 157   // Clone to thunk.
 158   llvm::ValueToValueMapTy VMap;
 159   llvm::Function *NewFn = llvm::CloneFunction(BaseFn, VMap);
 160   Fn->replaceAllUsesWith(NewFn);
 161   NewFn->takeName(Fn);
 162   Fn->eraseFromParent();
 163   Fn = NewFn;
 164
 165   // "Initialize" CGF (minimally).
 166   CurFn = Fn;
 167
 168   // Get the "this" value
 169   llvm::Function::arg_iterator AI = Fn->arg_begin();
 170   if (CGM.ReturnTypeUsesSRet(FnInfo))
 171     ++AI;
 172
 173   // Find the first store of "this", which will be to the alloca associated
 174   // with "this".
 175   Address ThisPtr(&*AI, CGM.getClassPointerAlignment(MD->getParent()));
 176   llvm::BasicBlock *EntryBB = &Fn->front();
 177   llvm::BasicBlock::iterator ThisStore =
 178       std::find_if(EntryBB->begin(), EntryBB->end(), [&](llvm::Instruction &I) {
 179         return isa<llvm::StoreInst>(I) &&
 180                I.getOperand(0) == ThisPtr.getPointer();
 181       });
 182   assert(ThisStore != EntryBB->end() &&
 183          "Store of this should be in entry block?");
 184   // Adjust "this", if necessary.
 185   Builder.SetInsertPoint(&*ThisStore);
 186   llvm::Value *AdjustedThisPtr =
 187       CGM.getCXXABI().performThisAdjustment(*this, ThisPtr, Thunk.This);
 188   ThisStore->setOperand(0, AdjustedThisPtr);
 189
 190   if (!Thunk.Return.isEmpty()) {
 191     // Fix up the returned value, if necessary.
 192     for (llvm::BasicBlock &BB : *Fn) {
 193       llvm::Instruction *T = BB.getTerminator();
 194       if (isa<llvm::ReturnInst>(T)) {
 195         RValue RV = RValue::get(T->getOperand(0));
 196         T->eraseFromParent();
 197         Builder.SetInsertPoint(&BB);
 198         RV = PerformReturnAdjustment(*this, ResultType, RV, Thunk);
 199         Builder.CreateRet(RV.getScalarVal());
 200         break;
 201       }
 202     }
 203   }
 204
 205   return Fn;
 206 }
 207
 208 void CodeGenFunction::StartThunk(llvm::Function *Fn, GlobalDecl GD,
 209                                  const CGFunctionInfo &FnInfo) {
 210   assert(!CurGD.getDecl() && "CurGD was already set!");
 211   CurGD = GD;
 212   CurFuncIsThunk = true;
 213
 214   // Build FunctionArgs.
 215   const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
 216   QualType ThisType = MD->getThisType(getContext());
 217   const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
 218   QualType ResultType = CGM.getCXXABI().HasThisReturn(GD)
 219                             ? ThisType
 220                             : CGM.getCXXABI().hasMostDerivedReturn(GD)
 221                                   ? CGM.getContext().VoidPtrTy
 222                                   : FPT->getReturnType();
 223   FunctionArgList FunctionArgs;
 224
 225   // Create the implicit 'this' parameter declaration.
 226   CGM.getCXXABI().buildThisParam(*this, FunctionArgs);
 227
 228   // Add the rest of the parameters.
 229   FunctionArgs.append(MD->param_begin(), MD->param_end());
 230
 231   if (isa<CXXDestructorDecl>(MD))
 232     CGM.getCXXABI().addImplicitStructorParams(*this, ResultType, FunctionArgs);
 233
 234   // Start defining the function.
 235   StartFunction(GlobalDecl(), ResultType, Fn, FnInfo, FunctionArgs,
 236                 MD->getLocation(), MD->getLocation());
 237
 238   // Since we didn't pass a GlobalDecl to StartFunction, do this ourselves.
 239   CGM.getCXXABI().EmitInstanceFunctionProlog(*this);
 240   CXXThisValue = CXXABIThisValue;
 241   CurCodeDecl = MD;
 242   CurFuncDecl = MD;
 243 }
 244
 245 void CodeGenFunction::FinishThunk() {
 246   // Clear these to restore the invariants expected by
 247   // StartFunction/FinishFunction.
 248   CurCodeDecl = nullptr;
 249   CurFuncDecl = nullptr;
 250
 251   FinishFunction();
 252 }
 253
 254 void CodeGenFunction::EmitCallAndReturnForThunk(llvm::Value *Callee,
 255                                                 const ThunkInfo *Thunk) {
 256   assert(isa<CXXMethodDecl>(CurGD.getDecl()) &&
 257          "Please use a new CGF for this thunk");
 258   const CXXMethodDecl *MD = cast<CXXMethodDecl>(CurGD.getDecl());
 259
 260   // Adjust the 'this' pointer if necessary
 261   llvm::Value *AdjustedThisPtr =
 262     Thunk ? CGM.getCXXABI().performThisAdjustment(
 263                           *this, LoadCXXThisAddress(), Thunk->This)
 264           : LoadCXXThis();
 265
 266   if (CurFnInfo->usesInAlloca()) {
 267     // We don't handle return adjusting thunks, because they require us to call
 268     // the copy constructor.  For now, fall through and pretend the return
 269     // adjustment was empty so we don't crash.
 270     if (Thunk && !Thunk->Return.isEmpty()) {
 271       CGM.ErrorUnsupported(
 272           MD, "non-trivial argument copy for return-adjusting thunk");
 273     }
 274     EmitMustTailThunk(MD, AdjustedThisPtr, Callee);
 275     return;
 276   }
 277
 278   // Start building CallArgs.
 279   CallArgList CallArgs;
 280   QualType ThisType = MD->getThisType(getContext());
 281   CallArgs.add(RValue::get(AdjustedThisPtr), ThisType);
 282
 283   if (isa<CXXDestructorDecl>(MD))
 284     CGM.getCXXABI().adjustCallArgsForDestructorThunk(*this, CurGD, CallArgs);
 285
 286   // Add the rest of the arguments.
 287   for (const ParmVarDecl *PD : MD->parameters())
 288     EmitDelegateCallArg(CallArgs, PD, PD->getLocStart());
 289
 290   const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
 291
 292 #ifndef NDEBUG
 293   const CGFunctionInfo &CallFnInfo = CGM.getTypes().arrangeCXXMethodCall(
 294       CallArgs, FPT, RequiredArgs::forPrototypePlus(FPT, 1, MD));
 295   assert(CallFnInfo.getRegParm() == CurFnInfo->getRegParm() &&
 296          CallFnInfo.isNoReturn() == CurFnInfo->isNoReturn() &&
 297          CallFnInfo.getCallingConvention() == CurFnInfo->getCallingConvention());
 298   assert(isa<CXXDestructorDecl>(MD) || // ignore dtor return types
 299          similar(CallFnInfo.getReturnInfo(), CallFnInfo.getReturnType(),
 300                  CurFnInfo->getReturnInfo(), CurFnInfo->getReturnType()));
 301   assert(CallFnInfo.arg_size() == CurFnInfo->arg_size());
 302   for (unsigned i = 0, e = CurFnInfo->arg_size(); i != e; ++i)
 303     assert(similar(CallFnInfo.arg_begin()[i].info,
 304                    CallFnInfo.arg_begin()[i].type,
 305                    CurFnInfo->arg_begin()[i].info,
 306                    CurFnInfo->arg_begin()[i].type));
 307 #endif
 308
 309   // Determine whether we have a return value slot to use.
 310   QualType ResultType = CGM.getCXXABI().HasThisReturn(CurGD)
 311                             ? ThisType
 312                             : CGM.getCXXABI().hasMostDerivedReturn(CurGD)
 313                                   ? CGM.getContext().VoidPtrTy
 314                                   : FPT->getReturnType();
 315   ReturnValueSlot Slot;
 316   if (!ResultType->isVoidType() &&
 317       CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect &&
 318       !hasScalarEvaluationKind(CurFnInfo->getReturnType()))
 319     Slot = ReturnValueSlot(ReturnValue, ResultType.isVolatileQualified());
 320
 321   // Now emit our call.
 322   llvm::Instruction *CallOrInvoke;
 323   RValue RV = EmitCall(*CurFnInfo, Callee, Slot, CallArgs, MD, &CallOrInvoke);
 324
 325   // Consider return adjustment if we have ThunkInfo.
 326   if (Thunk && !Thunk->Return.isEmpty())
 327     RV = PerformReturnAdjustment(*this, ResultType, RV, *Thunk);
 328   else if (llvm::CallInst* Call = dyn_cast<llvm::CallInst>(CallOrInvoke))
 329     Call->setTailCallKind(llvm::CallInst::TCK_Tail);
 330
 331   // Emit return.
 332   if (!ResultType->isVoidType() && Slot.isNull())
 333     CGM.getCXXABI().EmitReturnFromThunk(*this, RV, ResultType);
 334
 335   // Disable the final ARC autorelease.
 336   AutoreleaseResult = false;
 337
 338   FinishThunk();
 339 }
 340
 341 void CodeGenFunction::EmitMustTailThunk(const CXXMethodDecl *MD,
 342                                         llvm::Value *AdjustedThisPtr,
 343                                         llvm::Value *Callee) {
 344   // Emitting a musttail call thunk doesn't use any of the CGCall.cpp machinery
 345   // to translate AST arguments into LLVM IR arguments.  For thunks, we know
 346   // that the caller prototype more or less matches the callee prototype with
 347   // the exception of 'this'.
 348   SmallVector<llvm::Value *, 8> Args;
 349   for (llvm::Argument &A : CurFn->args())
 350     Args.push_back(&A);
 351
 352   // Set the adjusted 'this' pointer.
 353   const ABIArgInfo &ThisAI = CurFnInfo->arg_begin()->info;
 354   if (ThisAI.isDirect()) {
 355     const ABIArgInfo &RetAI = CurFnInfo->getReturnInfo();
 356     int ThisArgNo = RetAI.isIndirect() && !RetAI.isSRetAfterThis() ? 1 : 0;
 357     llvm::Type *ThisType = Args[ThisArgNo]->getType();
 358     if (ThisType != AdjustedThisPtr->getType())
 359       AdjustedThisPtr = Builder.CreateBitCast(AdjustedThisPtr, ThisType);
 360     Args[ThisArgNo] = AdjustedThisPtr;
 361   } else {
 362     assert(ThisAI.isInAlloca() && "this is passed directly or inalloca");
 363     Address ThisAddr = GetAddrOfLocalVar(CXXABIThisDecl);
 364     llvm::Type *ThisType = ThisAddr.getElementType();
 365     if (ThisType != AdjustedThisPtr->getType())
 366       AdjustedThisPtr = Builder.CreateBitCast(AdjustedThisPtr, ThisType);
 367     Builder.CreateStore(AdjustedThisPtr, ThisAddr);
 368   }
 369
 370   // Emit the musttail call manually.  Even if the prologue pushed cleanups, we
 371   // don't actually want to run them.
 372   llvm::CallInst *Call = Builder.CreateCall(Callee, Args);
 373   Call->setTailCallKind(llvm::CallInst::TCK_MustTail);
 374
 375   // Apply the standard set of call attributes.
 376   unsigned CallingConv;
 377   CodeGen::AttributeListType AttributeList;
 378   CGM.ConstructAttributeList(Callee->getName(), *CurFnInfo, MD, AttributeList,
 379                              CallingConv, /*AttrOnCallSite=*/true);
 380   llvm::AttributeSet Attrs =
 381       llvm::AttributeSet::get(getLLVMContext(), AttributeList);
 382   Call->setAttributes(Attrs);
 383   Call->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
 384
 385   if (Call->getType()->isVoidTy())
 386     Builder.CreateRetVoid();
 387   else
 388     Builder.CreateRet(Call);
 389
 390   // Finish the function to maintain CodeGenFunction invariants.
 391   // FIXME: Don't emit unreachable code.
 392   EmitBlock(createBasicBlock());
 393   FinishFunction();
 394 }
 395
 396 void CodeGenFunction::generateThunk(llvm::Function *Fn,
 397                                     const CGFunctionInfo &FnInfo,
 398                                     GlobalDecl GD, const ThunkInfo &Thunk) {
 399   StartThunk(Fn, GD, FnInfo);
 400
 401   // Get our callee.
 402   llvm::Type *Ty =
 403     CGM.getTypes().GetFunctionType(CGM.getTypes().arrangeGlobalDeclaration(GD));
 404   llvm::Value *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true);
 405
 406   // Make the call and return the result.
 407   EmitCallAndReturnForThunk(Callee, &Thunk);
 408 }
 409
 410 void CodeGenVTables::emitThunk(GlobalDecl GD, const ThunkInfo &Thunk,
 411                                bool ForVTable) {
 412   const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeGlobalDeclaration(GD);
 413
 414   // FIXME: re-use FnInfo in this computation.
 415   llvm::Constant *C = CGM.GetAddrOfThunk(GD, Thunk);
 416   llvm::GlobalValue *Entry;
 417
 418   // Strip off a bitcast if we got one back.
 419   if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(C)) {
 420     assert(CE->getOpcode() == llvm::Instruction::BitCast);
 421     Entry = cast<llvm::GlobalValue>(CE->getOperand(0));
 422   } else {
 423     Entry = cast<llvm::GlobalValue>(C);
 424   }
 425
 426   // There's already a declaration with the same name, check if it has the same
 427   // type or if we need to replace it.
 428   if (Entry->getType()->getElementType() !=
 429       CGM.getTypes().GetFunctionTypeForVTable(GD)) {
 430     llvm::GlobalValue *OldThunkFn = Entry;
 431
 432     // If the types mismatch then we have to rewrite the definition.
 433     assert(OldThunkFn->isDeclaration() &&
 434            "Shouldn't replace non-declaration");
 435
 436     // Remove the name from the old thunk function and get a new thunk.
 437     OldThunkFn->setName(StringRef());
 438     Entry = cast<llvm::GlobalValue>(CGM.GetAddrOfThunk(GD, Thunk));
 439
 440     // If needed, replace the old thunk with a bitcast.
 441     if (!OldThunkFn->use_empty()) {
 442       llvm::Constant *NewPtrForOldDecl =
 443         llvm::ConstantExpr::getBitCast(Entry, OldThunkFn->getType());
 444       OldThunkFn->replaceAllUsesWith(NewPtrForOldDecl);
 445     }
 446
 447     // Remove the old thunk.
 448     OldThunkFn->eraseFromParent();
 449   }
 450
 451   llvm::Function *ThunkFn = cast<llvm::Function>(Entry);
 452   bool ABIHasKeyFunctions = CGM.getTarget().getCXXABI().hasKeyFunctions();
 453   bool UseAvailableExternallyLinkage = ForVTable && ABIHasKeyFunctions;
 454
 455   if (!ThunkFn->isDeclaration()) {
 456     if (!ABIHasKeyFunctions || UseAvailableExternallyLinkage) {
 457       // There is already a thunk emitted for this function, do nothing.
 458       return;
 459     }
 460
 461     setThunkProperties(CGM, Thunk, ThunkFn, ForVTable, GD);
 462     return;
 463   }
 464
 465   CGM.SetLLVMFunctionAttributesForDefinition(GD.getDecl(), ThunkFn);
 466
 467   if (ThunkFn->isVarArg()) {
 468     // Varargs thunks are special; we can't just generate a call because
 469     // we can't copy the varargs.  Our implementation is rather
 470     // expensive/sucky at the moment, so don't generate the thunk unless
 471     // we have to.
 472     // FIXME: Do something better here; GenerateVarArgsThunk is extremely ugly.
 473     if (UseAvailableExternallyLinkage)
 474       return;
 475     ThunkFn =
 476         CodeGenFunction(CGM).GenerateVarArgsThunk(ThunkFn, FnInfo, GD, Thunk);
 477   } else {
 478     // Normal thunk body generation.
 479     CodeGenFunction(CGM).generateThunk(ThunkFn, FnInfo, GD, Thunk);
 480   }
 481
 482   setThunkProperties(CGM, Thunk, ThunkFn, ForVTable, GD);
 483 }
 484
 485 void CodeGenVTables::maybeEmitThunkForVTable(GlobalDecl GD,
 486                                              const ThunkInfo &Thunk) {
 487   // If the ABI has key functions, only the TU with the key function should emit
 488   // the thunk. However, we can allow inlining of thunks if we emit them with
 489   // available_externally linkage together with vtables when optimizations are
 490   // enabled.
 491   if (CGM.getTarget().getCXXABI().hasKeyFunctions() &&
 492       !CGM.getCodeGenOpts().OptimizationLevel)
 493     return;
 494
 495   // We can't emit thunks for member functions with incomplete types.
 496   const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
 497   if (!CGM.getTypes().isFuncTypeConvertible(
 498            MD->getType()->castAs<FunctionType>()))
 499     return;
 500
 501   emitThunk(GD, Thunk, /*ForVTable=*/true);
 502 }
 503
 504 void CodeGenVTables::EmitThunks(GlobalDecl GD)
 505 {
 506   const CXXMethodDecl *MD =
 507     cast<CXXMethodDecl>(GD.getDecl())->getCanonicalDecl();
 508
 509   // We don't need to generate thunks for the base destructor.
 510   if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() == Dtor_Base)
 511     return;
 512
 513   const VTableContextBase::ThunkInfoVectorTy *ThunkInfoVector =
 514       VTContext->getThunkInfo(GD);
 515
 516   if (!ThunkInfoVector)
 517     return;
 518
 519   for (const ThunkInfo& Thunk : *ThunkInfoVector)
 520     emitThunk(GD, Thunk, /*ForVTable=*/false);
 521 }
 522
 523 llvm::Constant *CodeGenVTables::CreateVTableInitializer(
 524     const CXXRecordDecl *RD, const VTableComponent *Components,
 525     unsigned NumComponents, const VTableLayout::VTableThunkTy *VTableThunks,
 526     unsigned NumVTableThunks, llvm::Constant *RTTI) {
 527   SmallVector<llvm::Constant *, 64> Inits;
 528
 529   llvm::Type *Int8PtrTy = CGM.Int8PtrTy;
 530
 531   llvm::Type *PtrDiffTy =
 532     CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
 533
 534   unsigned NextVTableThunkIndex = 0;
 535
 536   llvm::Constant *PureVirtualFn = nullptr, *DeletedVirtualFn = nullptr;
 537
 538   for (unsigned I = 0; I != NumComponents; ++I) {
 539     VTableComponent Component = Components[I];
 540
 541     llvm::Constant *Init = nullptr;
 542
 543     switch (Component.getKind()) {
 544     case VTableComponent::CK_VCallOffset:
 545       Init = llvm::ConstantInt::get(PtrDiffTy,
 546                                     Component.getVCallOffset().getQuantity());
 547       Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
 548       break;
 549     case VTableComponent::CK_VBaseOffset:
 550       Init = llvm::ConstantInt::get(PtrDiffTy,
 551                                     Component.getVBaseOffset().getQuantity());
 552       Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
 553       break;
 554     case VTableComponent::CK_OffsetToTop:
 555       Init = llvm::ConstantInt::get(PtrDiffTy,
 556                                     Component.getOffsetToTop().getQuantity());
 557       Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
 558       break;
 559     case VTableComponent::CK_RTTI:
 560       Init = llvm::ConstantExpr::getBitCast(RTTI, Int8PtrTy);
 561       break;
 562     case VTableComponent::CK_FunctionPointer:
 563     case VTableComponent::CK_CompleteDtorPointer:
 564     case VTableComponent::CK_DeletingDtorPointer: {
 565       GlobalDecl GD;
 566
 567       // Get the right global decl.
 568       switch (Component.getKind()) {
 569       default:
 570         llvm_unreachable("Unexpected vtable component kind");
 571       case VTableComponent::CK_FunctionPointer:
 572         GD = Component.getFunctionDecl();
 573         break;
 574       case VTableComponent::CK_CompleteDtorPointer:
 575         GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Complete);
 576         break;
 577       case VTableComponent::CK_DeletingDtorPointer:
 578         GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Deleting);
 579         break;
 580       }
 581
 582       if (CGM.getLangOpts().CUDA) {
 583         // Emit NULL for methods we can't codegen on this
 584         // side. Otherwise we'd end up with vtable with unresolved
 585         // references.
 586         const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
 587         // OK on device side: functions w/ __device__ attribute
 588         // OK on host side: anything except __device__-only functions.
 589         bool CanEmitMethod = CGM.getLangOpts().CUDAIsDevice
 590                                  ? MD->hasAttr<CUDADeviceAttr>()
 591                                  : (MD->hasAttr<CUDAHostAttr>() ||
 592                                     !MD->hasAttr<CUDADeviceAttr>());
 593         if (!CanEmitMethod) {
 594           Init = llvm::ConstantExpr::getNullValue(Int8PtrTy);
 595           break;
 596         }
 597         // Method is acceptable, continue processing as usual.
 598       }
 599
 600       if (cast<CXXMethodDecl>(GD.getDecl())->isPure()) {
 601         // We have a pure virtual member function.
 602         if (!PureVirtualFn) {
 603           llvm::FunctionType *Ty =
 604             llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
 605           StringRef PureCallName = CGM.getCXXABI().GetPureVirtualCallName();
 606           PureVirtualFn = CGM.CreateRuntimeFunction(Ty, PureCallName);
 607           if (auto *F = dyn_cast<llvm::Function>(PureVirtualFn))
 608             F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
 609           PureVirtualFn = llvm::ConstantExpr::getBitCast(PureVirtualFn,
 610                                                          CGM.Int8PtrTy);
 611         }
 612         Init = PureVirtualFn;
 613       } else if (cast<CXXMethodDecl>(GD.getDecl())->isDeleted()) {
 614         if (!DeletedVirtualFn) {
 615           llvm::FunctionType *Ty =
 616             llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
 617           StringRef DeletedCallName =
 618             CGM.getCXXABI().GetDeletedVirtualCallName();
 619           DeletedVirtualFn = CGM.CreateRuntimeFunction(Ty, DeletedCallName);
 620           if (auto *F = dyn_cast<llvm::Function>(DeletedVirtualFn))
 621             F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
 622           DeletedVirtualFn = llvm::ConstantExpr::getBitCast(DeletedVirtualFn,
 623                                                          CGM.Int8PtrTy);
 624         }
 625         Init = DeletedVirtualFn;
 626       } else {
 627         // Check if we should use a thunk.
 628         if (NextVTableThunkIndex < NumVTableThunks &&
 629             VTableThunks[NextVTableThunkIndex].first == I) {
 630           const ThunkInfo &Thunk = VTableThunks[NextVTableThunkIndex].second;
 631
 632           maybeEmitThunkForVTable(GD, Thunk);
 633           Init = CGM.GetAddrOfThunk(GD, Thunk);
 634
 635           NextVTableThunkIndex++;
 636         } else {
 637           llvm::Type *Ty = CGM.getTypes().GetFunctionTypeForVTable(GD);
 638
 639           Init = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true);
 640         }
 641
 642         Init = llvm::ConstantExpr::getBitCast(Init, Int8PtrTy);
 643       }
 644       break;
 645     }
 646
 647     case VTableComponent::CK_UnusedFunctionPointer:
 648       Init = llvm::ConstantExpr::getNullValue(Int8PtrTy);
 649       break;
 650     };
 651
 652     Inits.push_back(Init);
 653   }
 654
 655   llvm::ArrayType *ArrayType = llvm::ArrayType::get(Int8PtrTy, NumComponents);
 656   return llvm::ConstantArray::get(ArrayType, Inits);
 657 }
 658
 659 llvm::GlobalVariable *
 660 CodeGenVTables::GenerateConstructionVTable(const CXXRecordDecl *RD,
 661                                       const BaseSubobject &Base,
 662                                       bool BaseIsVirtual,
 663                                    llvm::GlobalVariable::LinkageTypes Linkage,
 664                                       VTableAddressPointsMapTy& AddressPoints) {
 665   if (CGDebugInfo *DI = CGM.getModuleDebugInfo())
 666     DI->completeClassData(Base.getBase());
 667
 668   std::unique_ptr<VTableLayout> VTLayout(
 669       getItaniumVTableContext().createConstructionVTableLayout(
 670           Base.getBase(), Base.getBaseOffset(), BaseIsVirtual, RD));
 671
 672   // Add the address points.
 673   AddressPoints = VTLayout->getAddressPoints();
 674
 675   // Get the mangled construction vtable name.
 676   SmallString<256> OutName;
 677   llvm::raw_svector_ostream Out(OutName);
 678   cast<ItaniumMangleContext>(CGM.getCXXABI().getMangleContext())
 679       .mangleCXXCtorVTable(RD, Base.getBaseOffset().getQuantity(),
 680                            Base.getBase(), Out);
 681   StringRef Name = OutName.str();
 682
 683   llvm::ArrayType *ArrayType =
 684     llvm::ArrayType::get(CGM.Int8PtrTy, VTLayout->getNumVTableComponents());
 685
 686   // Construction vtable symbols are not part of the Itanium ABI, so we cannot
 687   // guarantee that they actually will be available externally. Instead, when
 688   // emitting an available_externally VTT, we provide references to an internal
 689   // linkage construction vtable. The ABI only requires complete-object vtables
 690   // to be the same for all instances of a type, not construction vtables.
 691   if (Linkage == llvm::GlobalVariable::AvailableExternallyLinkage)
 692     Linkage = llvm::GlobalVariable::InternalLinkage;
 693
 694   // Create the variable that will hold the construction vtable.
 695   llvm::GlobalVariable *VTable =
 696     CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType, Linkage);
 697   CGM.setGlobalVisibility(VTable, RD);
 698
 699   // V-tables are always unnamed_addr.
 700   VTable->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
 701
 702   llvm::Constant *RTTI = CGM.GetAddrOfRTTIDescriptor(
 703       CGM.getContext().getTagDeclType(Base.getBase()));
 704
 705   // Create and set the initializer.
 706   llvm::Constant *Init = CreateVTableInitializer(
 707       Base.getBase(), VTLayout->vtable_component_begin(),
 708       VTLayout->getNumVTableComponents(), VTLayout->vtable_thunk_begin(),
 709       VTLayout->getNumVTableThunks(), RTTI);
 710   VTable->setInitializer(Init);
 711
 712   CGM.EmitVTableTypeMetadata(VTable, *VTLayout.get());
 713
 714   return VTable;
 715 }
 716
 717 static bool shouldEmitAvailableExternallyVTable(const CodeGenModule &CGM,
 718                                                 const CXXRecordDecl *RD) {
 719   return CGM.getCodeGenOpts().OptimizationLevel > 0 &&
 720          CGM.getCXXABI().canSpeculativelyEmitVTable(RD);
 721 }
 722
 723 /// Compute the required linkage of the vtable for the given class.
 724 ///
 725 /// Note that we only call this at the end of the translation unit.
 726 llvm::GlobalVariable::LinkageTypes
 727 CodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) {
 728   if (!RD->isExternallyVisible())
 729     return llvm::GlobalVariable::InternalLinkage;
 730
 731   // We're at the end of the translation unit, so the current key
 732   // function is fully correct.
 733   const CXXMethodDecl *keyFunction = Context.getCurrentKeyFunction(RD);
 734   if (keyFunction && !RD->hasAttr<DLLImportAttr>()) {
 735     // If this class has a key function, use that to determine the
 736     // linkage of the vtable.
 737     const FunctionDecl *def = nullptr;
 738     if (keyFunction->hasBody(def))
 739       keyFunction = cast<CXXMethodDecl>(def);
 740
 741     switch (keyFunction->getTemplateSpecializationKind()) {
 742       case TSK_Undeclared:
 743       case TSK_ExplicitSpecialization:
 744         assert((def || CodeGenOpts.OptimizationLevel > 0) &&
 745                "Shouldn't query vtable linkage without key function or "
 746                "optimizations");
 747         if (!def && CodeGenOpts.OptimizationLevel > 0)
 748           return llvm::GlobalVariable::AvailableExternallyLinkage;
 749
 750         if (keyFunction->isInlined())
 751           return !Context.getLangOpts().AppleKext ?
 752                    llvm::GlobalVariable::LinkOnceODRLinkage :
 753                    llvm::Function::InternalLinkage;
 754
 755         return llvm::GlobalVariable::ExternalLinkage;
 756
 757       case TSK_ImplicitInstantiation:
 758         return !Context.getLangOpts().AppleKext ?
 759                  llvm::GlobalVariable::LinkOnceODRLinkage :
 760                  llvm::Function::InternalLinkage;
 761
 762       case TSK_ExplicitInstantiationDefinition:
 763         return !Context.getLangOpts().AppleKext ?
 764                  llvm::GlobalVariable::WeakODRLinkage :
 765                  llvm::Function::InternalLinkage;
 766
 767       case TSK_ExplicitInstantiationDeclaration:
 768         llvm_unreachable("Should not have been asked to emit this");
 769     }
 770   }
 771
 772   // -fapple-kext mode does not support weak linkage, so we must use
 773   // internal linkage.
 774   if (Context.getLangOpts().AppleKext)
 775     return llvm::Function::InternalLinkage;
 776
 777   llvm::GlobalVariable::LinkageTypes DiscardableODRLinkage =
 778       llvm::GlobalValue::LinkOnceODRLinkage;
 779   llvm::GlobalVariable::LinkageTypes NonDiscardableODRLinkage =
 780       llvm::GlobalValue::WeakODRLinkage;
 781   if (RD->hasAttr<DLLExportAttr>()) {
 782     // Cannot discard exported vtables.
 783     DiscardableODRLinkage = NonDiscardableODRLinkage;
 784   } else if (RD->hasAttr<DLLImportAttr>()) {
 785     // Imported vtables are available externally.
 786     DiscardableODRLinkage = llvm::GlobalVariable::AvailableExternallyLinkage;
 787     NonDiscardableODRLinkage = llvm::GlobalVariable::AvailableExternallyLinkage;
 788   }
 789
 790   switch (RD->getTemplateSpecializationKind()) {
 791     case TSK_Undeclared:
 792     case TSK_ExplicitSpecialization:
 793     case TSK_ImplicitInstantiation:
 794       return DiscardableODRLinkage;
 795
 796     case TSK_ExplicitInstantiationDeclaration:
 797       // Explicit instantiations in MSVC do not provide vtables, so we must emit
 798       // our own.
 799       if (getTarget().getCXXABI().isMicrosoft())
 800         return DiscardableODRLinkage;
 801       return shouldEmitAvailableExternallyVTable(*this, RD)
 802                  ? llvm::GlobalVariable::AvailableExternallyLinkage
 803                  : llvm::GlobalVariable::ExternalLinkage;
 804
 805     case TSK_ExplicitInstantiationDefinition:
 806       return NonDiscardableODRLinkage;
 807   }
 808
 809   llvm_unreachable("Invalid TemplateSpecializationKind!");
 810 }
 811
 812 /// This is a callback from Sema to tell us that that a particular vtable is
 813 /// required to be emitted in this translation unit.
 814 ///
 815 /// This is only called for vtables that _must_ be emitted (mainly due to key
 816 /// functions).  For weak vtables, CodeGen tracks when they are needed and
 817 /// emits them as-needed.
 818 void CodeGenModule::EmitVTable(CXXRecordDecl *theClass) {
 819   VTables.GenerateClassData(theClass);
 820 }
 821
 822 void
 823 CodeGenVTables::GenerateClassData(const CXXRecordDecl *RD) {
 824   if (CGDebugInfo *DI = CGM.getModuleDebugInfo())
 825     DI->completeClassData(RD);
 826
 827   if (RD->getNumVBases())
 828     CGM.getCXXABI().emitVirtualInheritanceTables(RD);
 829
 830   CGM.getCXXABI().emitVTableDefinitions(*this, RD);
 831 }
 832
 833 /// At this point in the translation unit, does it appear that can we
 834 /// rely on the vtable being defined elsewhere in the program?
 835 ///
 836 /// The response is really only definitive when called at the end of
 837 /// the translation unit.
 838 ///
 839 /// The only semantic restriction here is that the object file should
 840 /// not contain a vtable definition when that vtable is defined
 841 /// strongly elsewhere.  Otherwise, we'd just like to avoid emitting
 842 /// vtables when unnecessary.
 843 bool CodeGenVTables::isVTableExternal(const CXXRecordDecl *RD) {
 844   assert(RD->isDynamicClass() && "Non-dynamic classes have no VTable.");
 845
 846   // We always synthesize vtables if they are needed in the MS ABI. MSVC doesn't
 847   // emit them even if there is an explicit template instantiation.
 848   if (CGM.getTarget().getCXXABI().isMicrosoft())
 849     return false;
 850
 851   // If we have an explicit instantiation declaration (and not a
 852   // definition), the vtable is defined elsewhere.
 853   TemplateSpecializationKind TSK = RD->getTemplateSpecializationKind();
 854   if (TSK == TSK_ExplicitInstantiationDeclaration)
 855     return true;
 856
 857   // Otherwise, if the class is an instantiated template, the
 858   // vtable must be defined here.
 859   if (TSK == TSK_ImplicitInstantiation ||
 860       TSK == TSK_ExplicitInstantiationDefinition)
 861     return false;
 862
 863   // Otherwise, if the class doesn't have a key function (possibly
 864   // anymore), the vtable must be defined here.
 865   const CXXMethodDecl *keyFunction = CGM.getContext().getCurrentKeyFunction(RD);
 866   if (!keyFunction)
 867     return false;
 868
 869   // Otherwise, if we don't have a definition of the key function, the
 870   // vtable must be defined somewhere else.
 871   return !keyFunction->hasBody();
 872 }
 873
 874 /// Given that we're currently at the end of the translation unit, and
 875 /// we've emitted a reference to the vtable for this class, should
 876 /// we define that vtable?
 877 static bool shouldEmitVTableAtEndOfTranslationUnit(CodeGenModule &CGM,
 878                                                    const CXXRecordDecl *RD) {
 879   // If vtable is internal then it has to be done.
 880   if (!CGM.getVTables().isVTableExternal(RD))
 881     return true;
 882
 883   // If it's external then maybe we will need it as available_externally.
 884   return shouldEmitAvailableExternallyVTable(CGM, RD);
 885 }
 886
 887 /// Given that at some point we emitted a reference to one or more
 888 /// vtables, and that we are now at the end of the translation unit,
 889 /// decide whether we should emit them.
 890 void CodeGenModule::EmitDeferredVTables() {
 891 #ifndef NDEBUG
 892   // Remember the size of DeferredVTables, because we're going to assume
 893   // that this entire operation doesn't modify it.
 894   size_t savedSize = DeferredVTables.size();
 895 #endif
 896
 897   for (const CXXRecordDecl *RD : DeferredVTables)
 898     if (shouldEmitVTableAtEndOfTranslationUnit(*this, RD))
 899       VTables.GenerateClassData(RD);
 900
 901   assert(savedSize == DeferredVTables.size() &&
 902          "deferred extra vtables during vtable emission?");
 903   DeferredVTables.clear();
 904 }
 905
 906 bool CodeGenModule::HasHiddenLTOVisibility(const CXXRecordDecl *RD) {
 907   LinkageInfo LV = RD->getLinkageAndVisibility();
 908   if (!isExternallyVisible(LV.getLinkage()))
 909     return true;
 910
 911   if (RD->hasAttr<LTOVisibilityPublicAttr>() || RD->hasAttr<UuidAttr>())
 912     return false;
 913
 914   if (getTriple().isOSBinFormatCOFF()) {
 915     if (RD->hasAttr<DLLExportAttr>() || RD->hasAttr<DLLImportAttr>())
 916       return false;
 917   } else {
 918     if (LV.getVisibility() != HiddenVisibility)
 919       return false;
 920   }
 921
 922   if (getCodeGenOpts().LTOVisibilityPublicStd) {
 923     const DeclContext *DC = RD;
 924     while (1) {
 925       auto *D = cast<Decl>(DC);
 926       DC = DC->getParent();
 927       if (isa<TranslationUnitDecl>(DC->getRedeclContext())) {
 928         if (auto *ND = dyn_cast<NamespaceDecl>(D))
 929           if (const IdentifierInfo *II = ND->getIdentifier())
 930             if (II->isStr("std") || II->isStr("stdext"))
 931               return false;
 932         break;
 933       }
 934     }
 935   }
 936
 937   return true;
 938 }
 939
 940 void CodeGenModule::EmitVTableTypeMetadata(llvm::GlobalVariable *VTable,
 941                                            const VTableLayout &VTLayout) {
 942   if (!getCodeGenOpts().PrepareForLTO)
 943     return;
 944
 945   CharUnits PointerWidth =
 946       Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0));
 947
 948   typedef std::pair<const CXXRecordDecl *, unsigned> BSEntry;
 949   std::vector<BSEntry> BitsetEntries;
 950   // Create a bit set entry for each address point.
 951   for (auto &&AP : VTLayout.getAddressPoints())
 952     BitsetEntries.push_back(std::make_pair(AP.first.getBase(), AP.second));
 953
 954   // Sort the bit set entries for determinism.
 955   std::sort(BitsetEntries.begin(), BitsetEntries.end(),
 956             [this](const BSEntry &E1, const BSEntry &E2) {
 957     if (&E1 == &E2)
 958       return false;
 959
 960     std::string S1;
 961     llvm::raw_string_ostream O1(S1);
 962     getCXXABI().getMangleContext().mangleTypeName(
 963         QualType(E1.first->getTypeForDecl(), 0), O1);
 964     O1.flush();
 965
 966     std::string S2;
 967     llvm::raw_string_ostream O2(S2);
 968     getCXXABI().getMangleContext().mangleTypeName(
 969         QualType(E2.first->getTypeForDecl(), 0), O2);
 970     O2.flush();
 971
 972     if (S1 < S2)
 973       return true;
 974     if (S1 != S2)
 975       return false;
 976
 977     return E1.second < E2.second;
 978   });
 979
 980   for (auto BitsetEntry : BitsetEntries)
 981     AddVTableTypeMetadata(VTable, PointerWidth * BitsetEntry.second,
 982                           BitsetEntry.first);
 983 }