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