1 //===--- CGVTables.cpp - Emit LLVM Code for C++ vtables -------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This contains code dealing with C++ code generation of virtual tables.
12 //===----------------------------------------------------------------------===//
14 #include "CodeGenFunction.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"
29 using namespace clang;
30 using namespace CodeGen;
32 CodeGenVTables::CodeGenVTables(CodeGenModule &CGM)
33 : CGM(CGM), VTContext(CGM.getContext().getVTableContext()) {}
35 llvm::Constant *CodeGenModule::GetAddrOfThunk(GlobalDecl GD,
36 const ThunkInfo &Thunk) {
37 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
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(),
46 getCXXABI().getMangleContext().mangleThunk(MD, Thunk, Out);
48 llvm::Type *Ty = getTypes().GetFunctionTypeForVTable(GD);
49 return GetOrCreateLLVMFunction(Name, Ty, GD, /*ForVTable=*/true,
50 /*DontDefer=*/true, /*IsThunk=*/true);
53 static void setThunkVisibility(CodeGenModule &CGM, const CXXMethodDecl *MD,
54 const ThunkInfo &Thunk, llvm::Function *Fn) {
55 CGM.setGlobalVisibility(Fn, MD);
58 static void setThunkProperties(CodeGenModule &CGM, const ThunkInfo &Thunk,
59 llvm::Function *ThunkFn, bool ForVTable,
61 CGM.setFunctionLinkage(GD, ThunkFn);
62 CGM.getCXXABI().setThunkLinkage(ThunkFn, ForVTable, GD,
63 !Thunk.Return.isEmpty());
65 // Set the right visibility.
66 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
67 setThunkVisibility(CGM, MD, Thunk, ThunkFn);
69 if (CGM.supportsCOMDAT() && ThunkFn->isWeakForLinker())
70 ThunkFn->setComdat(CGM.getModule().getOrInsertComdat(ThunkFn->getName()));
74 static bool similar(const ABIArgInfo &infoL, CanQualType typeL,
75 const ABIArgInfo &infoR, CanQualType typeR) {
76 return (infoL.getKind() == infoR.getKind() &&
78 (isa<PointerType>(typeL) && isa<PointerType>(typeR)) ||
79 (isa<ReferenceType>(typeL) && isa<ReferenceType>(typeR))));
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();
89 llvm::BasicBlock *AdjustNull = nullptr;
90 llvm::BasicBlock *AdjustNotNull = nullptr;
91 llvm::BasicBlock *AdjustEnd = nullptr;
93 llvm::Value *ReturnValue = RV.getScalarVal();
96 AdjustNull = CGF.createBasicBlock("adjust.null");
97 AdjustNotNull = CGF.createBasicBlock("adjust.notnull");
98 AdjustEnd = CGF.createBasicBlock("adjust.end");
100 llvm::Value *IsNull = CGF.Builder.CreateIsNull(ReturnValue);
101 CGF.Builder.CreateCondBr(IsNull, AdjustNull, AdjustNotNull);
102 CGF.EmitBlock(AdjustNotNull);
105 auto ClassDecl = ResultType->getPointeeType()->getAsCXXRecordDecl();
106 auto ClassAlign = CGF.CGM.getClassPointerAlignment(ClassDecl);
107 ReturnValue = CGF.CGM.getCXXABI().performReturnAdjustment(CGF,
108 Address(ReturnValue, ClassAlign),
111 if (NullCheckValue) {
112 CGF.Builder.CreateBr(AdjustEnd);
113 CGF.EmitBlock(AdjustNull);
114 CGF.Builder.CreateBr(AdjustEnd);
115 CGF.EmitBlock(AdjustEnd);
117 llvm::PHINode *PHI = CGF.Builder.CreatePHI(ReturnValue->getType(), 2);
118 PHI->addIncoming(ReturnValue, AdjustNotNull);
119 PHI->addIncoming(llvm::Constant::getNullValue(ReturnValue->getType()),
124 return RValue::get(ReturnValue);
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.
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();
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);
158 llvm::ValueToValueMapTy VMap;
159 llvm::Function *NewFn = llvm::CloneFunction(BaseFn, VMap,
160 /*ModuleLevelChanges=*/false);
161 CGM.getModule().getFunctionList().push_back(NewFn);
162 Fn->replaceAllUsesWith(NewFn);
164 Fn->eraseFromParent();
167 // "Initialize" CGF (minimally).
170 // Get the "this" value
171 llvm::Function::arg_iterator AI = Fn->arg_begin();
172 if (CGM.ReturnTypeUsesSRet(FnInfo))
175 // Find the first store of "this", which will be to the alloca associated
177 Address ThisPtr(&*AI, CGM.getClassPointerAlignment(MD->getParent()));
178 llvm::BasicBlock *EntryBB = &Fn->front();
179 llvm::BasicBlock::iterator ThisStore =
180 std::find_if(EntryBB->begin(), EntryBB->end(), [&](llvm::Instruction &I) {
181 return isa<llvm::StoreInst>(I) &&
182 I.getOperand(0) == ThisPtr.getPointer();
184 assert(ThisStore != EntryBB->end() &&
185 "Store of this should be in entry block?");
186 // Adjust "this", if necessary.
187 Builder.SetInsertPoint(&*ThisStore);
188 llvm::Value *AdjustedThisPtr =
189 CGM.getCXXABI().performThisAdjustment(*this, ThisPtr, Thunk.This);
190 ThisStore->setOperand(0, AdjustedThisPtr);
192 if (!Thunk.Return.isEmpty()) {
193 // Fix up the returned value, if necessary.
194 for (llvm::BasicBlock &BB : *Fn) {
195 llvm::Instruction *T = BB.getTerminator();
196 if (isa<llvm::ReturnInst>(T)) {
197 RValue RV = RValue::get(T->getOperand(0));
198 T->eraseFromParent();
199 Builder.SetInsertPoint(&BB);
200 RV = PerformReturnAdjustment(*this, ResultType, RV, Thunk);
201 Builder.CreateRet(RV.getScalarVal());
210 void CodeGenFunction::StartThunk(llvm::Function *Fn, GlobalDecl GD,
211 const CGFunctionInfo &FnInfo) {
212 assert(!CurGD.getDecl() && "CurGD was already set!");
214 CurFuncIsThunk = true;
216 // Build FunctionArgs.
217 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
218 QualType ThisType = MD->getThisType(getContext());
219 const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
220 QualType ResultType = CGM.getCXXABI().HasThisReturn(GD)
222 : CGM.getCXXABI().hasMostDerivedReturn(GD)
223 ? CGM.getContext().VoidPtrTy
224 : FPT->getReturnType();
225 FunctionArgList FunctionArgs;
227 // Create the implicit 'this' parameter declaration.
228 CGM.getCXXABI().buildThisParam(*this, FunctionArgs);
230 // Add the rest of the parameters.
231 FunctionArgs.append(MD->param_begin(), MD->param_end());
233 if (isa<CXXDestructorDecl>(MD))
234 CGM.getCXXABI().addImplicitStructorParams(*this, ResultType, FunctionArgs);
236 // Start defining the function.
237 StartFunction(GlobalDecl(), ResultType, Fn, FnInfo, FunctionArgs,
238 MD->getLocation(), MD->getLocation());
240 // Since we didn't pass a GlobalDecl to StartFunction, do this ourselves.
241 CGM.getCXXABI().EmitInstanceFunctionProlog(*this);
242 CXXThisValue = CXXABIThisValue;
247 void CodeGenFunction::FinishThunk() {
248 // Clear these to restore the invariants expected by
249 // StartFunction/FinishFunction.
250 CurCodeDecl = nullptr;
251 CurFuncDecl = nullptr;
256 void CodeGenFunction::EmitCallAndReturnForThunk(llvm::Value *Callee,
257 const ThunkInfo *Thunk) {
258 assert(isa<CXXMethodDecl>(CurGD.getDecl()) &&
259 "Please use a new CGF for this thunk");
260 const CXXMethodDecl *MD = cast<CXXMethodDecl>(CurGD.getDecl());
262 // Adjust the 'this' pointer if necessary
263 llvm::Value *AdjustedThisPtr =
264 Thunk ? CGM.getCXXABI().performThisAdjustment(
265 *this, LoadCXXThisAddress(), Thunk->This)
268 if (CurFnInfo->usesInAlloca()) {
269 // We don't handle return adjusting thunks, because they require us to call
270 // the copy constructor. For now, fall through and pretend the return
271 // adjustment was empty so we don't crash.
272 if (Thunk && !Thunk->Return.isEmpty()) {
273 CGM.ErrorUnsupported(
274 MD, "non-trivial argument copy for return-adjusting thunk");
276 EmitMustTailThunk(MD, AdjustedThisPtr, Callee);
280 // Start building CallArgs.
281 CallArgList CallArgs;
282 QualType ThisType = MD->getThisType(getContext());
283 CallArgs.add(RValue::get(AdjustedThisPtr), ThisType);
285 if (isa<CXXDestructorDecl>(MD))
286 CGM.getCXXABI().adjustCallArgsForDestructorThunk(*this, CurGD, CallArgs);
288 // Add the rest of the arguments.
289 for (const ParmVarDecl *PD : MD->params())
290 EmitDelegateCallArg(CallArgs, PD, PD->getLocStart());
292 const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
295 const CGFunctionInfo &CallFnInfo =
296 CGM.getTypes().arrangeCXXMethodCall(CallArgs, FPT,
297 RequiredArgs::forPrototypePlus(FPT, 1));
298 assert(CallFnInfo.getRegParm() == CurFnInfo->getRegParm() &&
299 CallFnInfo.isNoReturn() == CurFnInfo->isNoReturn() &&
300 CallFnInfo.getCallingConvention() == CurFnInfo->getCallingConvention());
301 assert(isa<CXXDestructorDecl>(MD) || // ignore dtor return types
302 similar(CallFnInfo.getReturnInfo(), CallFnInfo.getReturnType(),
303 CurFnInfo->getReturnInfo(), CurFnInfo->getReturnType()));
304 assert(CallFnInfo.arg_size() == CurFnInfo->arg_size());
305 for (unsigned i = 0, e = CurFnInfo->arg_size(); i != e; ++i)
306 assert(similar(CallFnInfo.arg_begin()[i].info,
307 CallFnInfo.arg_begin()[i].type,
308 CurFnInfo->arg_begin()[i].info,
309 CurFnInfo->arg_begin()[i].type));
312 // Determine whether we have a return value slot to use.
313 QualType ResultType = CGM.getCXXABI().HasThisReturn(CurGD)
315 : CGM.getCXXABI().hasMostDerivedReturn(CurGD)
316 ? CGM.getContext().VoidPtrTy
317 : FPT->getReturnType();
318 ReturnValueSlot Slot;
319 if (!ResultType->isVoidType() &&
320 CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect &&
321 !hasScalarEvaluationKind(CurFnInfo->getReturnType()))
322 Slot = ReturnValueSlot(ReturnValue, ResultType.isVolatileQualified());
324 // Now emit our call.
325 llvm::Instruction *CallOrInvoke;
326 RValue RV = EmitCall(*CurFnInfo, Callee, Slot, CallArgs, MD, &CallOrInvoke);
328 // Consider return adjustment if we have ThunkInfo.
329 if (Thunk && !Thunk->Return.isEmpty())
330 RV = PerformReturnAdjustment(*this, ResultType, RV, *Thunk);
331 else if (llvm::CallInst* Call = dyn_cast<llvm::CallInst>(CallOrInvoke))
332 Call->setTailCallKind(llvm::CallInst::TCK_Tail);
335 if (!ResultType->isVoidType() && Slot.isNull())
336 CGM.getCXXABI().EmitReturnFromThunk(*this, RV, ResultType);
338 // Disable the final ARC autorelease.
339 AutoreleaseResult = false;
344 void CodeGenFunction::EmitMustTailThunk(const CXXMethodDecl *MD,
345 llvm::Value *AdjustedThisPtr,
346 llvm::Value *Callee) {
347 // Emitting a musttail call thunk doesn't use any of the CGCall.cpp machinery
348 // to translate AST arguments into LLVM IR arguments. For thunks, we know
349 // that the caller prototype more or less matches the callee prototype with
350 // the exception of 'this'.
351 SmallVector<llvm::Value *, 8> Args;
352 for (llvm::Argument &A : CurFn->args())
355 // Set the adjusted 'this' pointer.
356 const ABIArgInfo &ThisAI = CurFnInfo->arg_begin()->info;
357 if (ThisAI.isDirect()) {
358 const ABIArgInfo &RetAI = CurFnInfo->getReturnInfo();
359 int ThisArgNo = RetAI.isIndirect() && !RetAI.isSRetAfterThis() ? 1 : 0;
360 llvm::Type *ThisType = Args[ThisArgNo]->getType();
361 if (ThisType != AdjustedThisPtr->getType())
362 AdjustedThisPtr = Builder.CreateBitCast(AdjustedThisPtr, ThisType);
363 Args[ThisArgNo] = AdjustedThisPtr;
365 assert(ThisAI.isInAlloca() && "this is passed directly or inalloca");
366 Address ThisAddr = GetAddrOfLocalVar(CXXABIThisDecl);
367 llvm::Type *ThisType = ThisAddr.getElementType();
368 if (ThisType != AdjustedThisPtr->getType())
369 AdjustedThisPtr = Builder.CreateBitCast(AdjustedThisPtr, ThisType);
370 Builder.CreateStore(AdjustedThisPtr, ThisAddr);
373 // Emit the musttail call manually. Even if the prologue pushed cleanups, we
374 // don't actually want to run them.
375 llvm::CallInst *Call = Builder.CreateCall(Callee, Args);
376 Call->setTailCallKind(llvm::CallInst::TCK_MustTail);
378 // Apply the standard set of call attributes.
379 unsigned CallingConv;
380 CodeGen::AttributeListType AttributeList;
381 CGM.ConstructAttributeList(Callee->getName(), *CurFnInfo, MD, AttributeList,
382 CallingConv, /*AttrOnCallSite=*/true);
383 llvm::AttributeSet Attrs =
384 llvm::AttributeSet::get(getLLVMContext(), AttributeList);
385 Call->setAttributes(Attrs);
386 Call->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
388 if (Call->getType()->isVoidTy())
389 Builder.CreateRetVoid();
391 Builder.CreateRet(Call);
393 // Finish the function to maintain CodeGenFunction invariants.
394 // FIXME: Don't emit unreachable code.
395 EmitBlock(createBasicBlock());
399 void CodeGenFunction::generateThunk(llvm::Function *Fn,
400 const CGFunctionInfo &FnInfo,
401 GlobalDecl GD, const ThunkInfo &Thunk) {
402 StartThunk(Fn, GD, FnInfo);
406 CGM.getTypes().GetFunctionType(CGM.getTypes().arrangeGlobalDeclaration(GD));
407 llvm::Value *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true);
409 // Make the call and return the result.
410 EmitCallAndReturnForThunk(Callee, &Thunk);
413 void CodeGenVTables::emitThunk(GlobalDecl GD, const ThunkInfo &Thunk,
415 const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeGlobalDeclaration(GD);
417 // FIXME: re-use FnInfo in this computation.
418 llvm::Constant *C = CGM.GetAddrOfThunk(GD, Thunk);
419 llvm::GlobalValue *Entry;
421 // Strip off a bitcast if we got one back.
422 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(C)) {
423 assert(CE->getOpcode() == llvm::Instruction::BitCast);
424 Entry = cast<llvm::GlobalValue>(CE->getOperand(0));
426 Entry = cast<llvm::GlobalValue>(C);
429 // There's already a declaration with the same name, check if it has the same
430 // type or if we need to replace it.
431 if (Entry->getType()->getElementType() !=
432 CGM.getTypes().GetFunctionTypeForVTable(GD)) {
433 llvm::GlobalValue *OldThunkFn = Entry;
435 // If the types mismatch then we have to rewrite the definition.
436 assert(OldThunkFn->isDeclaration() &&
437 "Shouldn't replace non-declaration");
439 // Remove the name from the old thunk function and get a new thunk.
440 OldThunkFn->setName(StringRef());
441 Entry = cast<llvm::GlobalValue>(CGM.GetAddrOfThunk(GD, Thunk));
443 // If needed, replace the old thunk with a bitcast.
444 if (!OldThunkFn->use_empty()) {
445 llvm::Constant *NewPtrForOldDecl =
446 llvm::ConstantExpr::getBitCast(Entry, OldThunkFn->getType());
447 OldThunkFn->replaceAllUsesWith(NewPtrForOldDecl);
450 // Remove the old thunk.
451 OldThunkFn->eraseFromParent();
454 llvm::Function *ThunkFn = cast<llvm::Function>(Entry);
455 bool ABIHasKeyFunctions = CGM.getTarget().getCXXABI().hasKeyFunctions();
456 bool UseAvailableExternallyLinkage = ForVTable && ABIHasKeyFunctions;
458 if (!ThunkFn->isDeclaration()) {
459 if (!ABIHasKeyFunctions || UseAvailableExternallyLinkage) {
460 // There is already a thunk emitted for this function, do nothing.
464 setThunkProperties(CGM, Thunk, ThunkFn, ForVTable, GD);
468 CGM.SetLLVMFunctionAttributesForDefinition(GD.getDecl(), ThunkFn);
470 if (ThunkFn->isVarArg()) {
471 // Varargs thunks are special; we can't just generate a call because
472 // we can't copy the varargs. Our implementation is rather
473 // expensive/sucky at the moment, so don't generate the thunk unless
475 // FIXME: Do something better here; GenerateVarArgsThunk is extremely ugly.
476 if (UseAvailableExternallyLinkage)
479 CodeGenFunction(CGM).GenerateVarArgsThunk(ThunkFn, FnInfo, GD, Thunk);
481 // Normal thunk body generation.
482 CodeGenFunction(CGM).generateThunk(ThunkFn, FnInfo, GD, Thunk);
485 setThunkProperties(CGM, Thunk, ThunkFn, ForVTable, GD);
488 void CodeGenVTables::maybeEmitThunkForVTable(GlobalDecl GD,
489 const ThunkInfo &Thunk) {
490 // If the ABI has key functions, only the TU with the key function should emit
491 // the thunk. However, we can allow inlining of thunks if we emit them with
492 // available_externally linkage together with vtables when optimizations are
494 if (CGM.getTarget().getCXXABI().hasKeyFunctions() &&
495 !CGM.getCodeGenOpts().OptimizationLevel)
498 // We can't emit thunks for member functions with incomplete types.
499 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
500 if (!CGM.getTypes().isFuncTypeConvertible(
501 MD->getType()->castAs<FunctionType>()))
504 emitThunk(GD, Thunk, /*ForVTable=*/true);
507 void CodeGenVTables::EmitThunks(GlobalDecl GD)
509 const CXXMethodDecl *MD =
510 cast<CXXMethodDecl>(GD.getDecl())->getCanonicalDecl();
512 // We don't need to generate thunks for the base destructor.
513 if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() == Dtor_Base)
516 const VTableContextBase::ThunkInfoVectorTy *ThunkInfoVector =
517 VTContext->getThunkInfo(GD);
519 if (!ThunkInfoVector)
522 for (const ThunkInfo& Thunk : *ThunkInfoVector)
523 emitThunk(GD, Thunk, /*ForVTable=*/false);
526 llvm::Constant *CodeGenVTables::CreateVTableInitializer(
527 const CXXRecordDecl *RD, const VTableComponent *Components,
528 unsigned NumComponents, const VTableLayout::VTableThunkTy *VTableThunks,
529 unsigned NumVTableThunks, llvm::Constant *RTTI) {
530 SmallVector<llvm::Constant *, 64> Inits;
532 llvm::Type *Int8PtrTy = CGM.Int8PtrTy;
534 llvm::Type *PtrDiffTy =
535 CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
537 unsigned NextVTableThunkIndex = 0;
539 llvm::Constant *PureVirtualFn = nullptr, *DeletedVirtualFn = nullptr;
541 for (unsigned I = 0; I != NumComponents; ++I) {
542 VTableComponent Component = Components[I];
544 llvm::Constant *Init = nullptr;
546 switch (Component.getKind()) {
547 case VTableComponent::CK_VCallOffset:
548 Init = llvm::ConstantInt::get(PtrDiffTy,
549 Component.getVCallOffset().getQuantity());
550 Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
552 case VTableComponent::CK_VBaseOffset:
553 Init = llvm::ConstantInt::get(PtrDiffTy,
554 Component.getVBaseOffset().getQuantity());
555 Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
557 case VTableComponent::CK_OffsetToTop:
558 Init = llvm::ConstantInt::get(PtrDiffTy,
559 Component.getOffsetToTop().getQuantity());
560 Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
562 case VTableComponent::CK_RTTI:
563 Init = llvm::ConstantExpr::getBitCast(RTTI, Int8PtrTy);
565 case VTableComponent::CK_FunctionPointer:
566 case VTableComponent::CK_CompleteDtorPointer:
567 case VTableComponent::CK_DeletingDtorPointer: {
570 // Get the right global decl.
571 switch (Component.getKind()) {
573 llvm_unreachable("Unexpected vtable component kind");
574 case VTableComponent::CK_FunctionPointer:
575 GD = Component.getFunctionDecl();
577 case VTableComponent::CK_CompleteDtorPointer:
578 GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Complete);
580 case VTableComponent::CK_DeletingDtorPointer:
581 GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Deleting);
585 if (CGM.getLangOpts().CUDA) {
586 // Emit NULL for methods we can't codegen on this
587 // side. Otherwise we'd end up with vtable with unresolved
589 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
590 // OK on device side: functions w/ __device__ attribute
591 // OK on host side: anything except __device__-only functions.
592 bool CanEmitMethod = CGM.getLangOpts().CUDAIsDevice
593 ? MD->hasAttr<CUDADeviceAttr>()
594 : (MD->hasAttr<CUDAHostAttr>() ||
595 !MD->hasAttr<CUDADeviceAttr>());
596 if (!CanEmitMethod) {
597 Init = llvm::ConstantExpr::getNullValue(Int8PtrTy);
600 // Method is acceptable, continue processing as usual.
603 if (cast<CXXMethodDecl>(GD.getDecl())->isPure()) {
604 // We have a pure virtual member function.
605 if (!PureVirtualFn) {
606 llvm::FunctionType *Ty =
607 llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
608 StringRef PureCallName = CGM.getCXXABI().GetPureVirtualCallName();
609 PureVirtualFn = CGM.CreateRuntimeFunction(Ty, PureCallName);
610 PureVirtualFn = llvm::ConstantExpr::getBitCast(PureVirtualFn,
613 Init = PureVirtualFn;
614 } else if (cast<CXXMethodDecl>(GD.getDecl())->isDeleted()) {
615 if (!DeletedVirtualFn) {
616 llvm::FunctionType *Ty =
617 llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
618 StringRef DeletedCallName =
619 CGM.getCXXABI().GetDeletedVirtualCallName();
620 DeletedVirtualFn = CGM.CreateRuntimeFunction(Ty, DeletedCallName);
621 DeletedVirtualFn = llvm::ConstantExpr::getBitCast(DeletedVirtualFn,
624 Init = DeletedVirtualFn;
626 // Check if we should use a thunk.
627 if (NextVTableThunkIndex < NumVTableThunks &&
628 VTableThunks[NextVTableThunkIndex].first == I) {
629 const ThunkInfo &Thunk = VTableThunks[NextVTableThunkIndex].second;
631 maybeEmitThunkForVTable(GD, Thunk);
632 Init = CGM.GetAddrOfThunk(GD, Thunk);
634 NextVTableThunkIndex++;
636 llvm::Type *Ty = CGM.getTypes().GetFunctionTypeForVTable(GD);
638 Init = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true);
641 Init = llvm::ConstantExpr::getBitCast(Init, Int8PtrTy);
646 case VTableComponent::CK_UnusedFunctionPointer:
647 Init = llvm::ConstantExpr::getNullValue(Int8PtrTy);
651 Inits.push_back(Init);
654 llvm::ArrayType *ArrayType = llvm::ArrayType::get(Int8PtrTy, NumComponents);
655 return llvm::ConstantArray::get(ArrayType, Inits);
658 llvm::GlobalVariable *
659 CodeGenVTables::GenerateConstructionVTable(const CXXRecordDecl *RD,
660 const BaseSubobject &Base,
662 llvm::GlobalVariable::LinkageTypes Linkage,
663 VTableAddressPointsMapTy& AddressPoints) {
664 if (CGDebugInfo *DI = CGM.getModuleDebugInfo())
665 DI->completeClassData(Base.getBase());
667 std::unique_ptr<VTableLayout> VTLayout(
668 getItaniumVTableContext().createConstructionVTableLayout(
669 Base.getBase(), Base.getBaseOffset(), BaseIsVirtual, RD));
671 // Add the address points.
672 AddressPoints = VTLayout->getAddressPoints();
674 // Get the mangled construction vtable name.
675 SmallString<256> OutName;
676 llvm::raw_svector_ostream Out(OutName);
677 cast<ItaniumMangleContext>(CGM.getCXXABI().getMangleContext())
678 .mangleCXXCtorVTable(RD, Base.getBaseOffset().getQuantity(),
679 Base.getBase(), Out);
680 StringRef Name = OutName.str();
682 llvm::ArrayType *ArrayType =
683 llvm::ArrayType::get(CGM.Int8PtrTy, VTLayout->getNumVTableComponents());
685 // Construction vtable symbols are not part of the Itanium ABI, so we cannot
686 // guarantee that they actually will be available externally. Instead, when
687 // emitting an available_externally VTT, we provide references to an internal
688 // linkage construction vtable. The ABI only requires complete-object vtables
689 // to be the same for all instances of a type, not construction vtables.
690 if (Linkage == llvm::GlobalVariable::AvailableExternallyLinkage)
691 Linkage = llvm::GlobalVariable::InternalLinkage;
693 // Create the variable that will hold the construction vtable.
694 llvm::GlobalVariable *VTable =
695 CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType, Linkage);
696 CGM.setGlobalVisibility(VTable, RD);
698 // V-tables are always unnamed_addr.
699 VTable->setUnnamedAddr(true);
701 llvm::Constant *RTTI = CGM.GetAddrOfRTTIDescriptor(
702 CGM.getContext().getTagDeclType(Base.getBase()));
704 // Create and set the initializer.
705 llvm::Constant *Init = CreateVTableInitializer(
706 Base.getBase(), VTLayout->vtable_component_begin(),
707 VTLayout->getNumVTableComponents(), VTLayout->vtable_thunk_begin(),
708 VTLayout->getNumVTableThunks(), RTTI);
709 VTable->setInitializer(Init);
711 CGM.EmitVTableBitSetEntries(VTable, *VTLayout.get());
716 static bool shouldEmitAvailableExternallyVTable(const CodeGenModule &CGM,
717 const CXXRecordDecl *RD) {
718 return CGM.getCodeGenOpts().OptimizationLevel > 0 &&
719 CGM.getCXXABI().canSpeculativelyEmitVTable(RD);
722 /// Compute the required linkage of the v-table for the given class.
724 /// Note that we only call this at the end of the translation unit.
725 llvm::GlobalVariable::LinkageTypes
726 CodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) {
727 if (!RD->isExternallyVisible())
728 return llvm::GlobalVariable::InternalLinkage;
730 // We're at the end of the translation unit, so the current key
731 // function is fully correct.
732 const CXXMethodDecl *keyFunction = Context.getCurrentKeyFunction(RD);
733 if (keyFunction && !RD->hasAttr<DLLImportAttr>()) {
734 // If this class has a key function, use that to determine the
735 // linkage of the vtable.
736 const FunctionDecl *def = nullptr;
737 if (keyFunction->hasBody(def))
738 keyFunction = cast<CXXMethodDecl>(def);
740 switch (keyFunction->getTemplateSpecializationKind()) {
742 case TSK_ExplicitSpecialization:
743 assert((def || CodeGenOpts.OptimizationLevel > 0) &&
744 "Shouldn't query vtable linkage without key function or "
746 if (!def && CodeGenOpts.OptimizationLevel > 0)
747 return llvm::GlobalVariable::AvailableExternallyLinkage;
749 if (keyFunction->isInlined())
750 return !Context.getLangOpts().AppleKext ?
751 llvm::GlobalVariable::LinkOnceODRLinkage :
752 llvm::Function::InternalLinkage;
754 return llvm::GlobalVariable::ExternalLinkage;
756 case TSK_ImplicitInstantiation:
757 return !Context.getLangOpts().AppleKext ?
758 llvm::GlobalVariable::LinkOnceODRLinkage :
759 llvm::Function::InternalLinkage;
761 case TSK_ExplicitInstantiationDefinition:
762 return !Context.getLangOpts().AppleKext ?
763 llvm::GlobalVariable::WeakODRLinkage :
764 llvm::Function::InternalLinkage;
766 case TSK_ExplicitInstantiationDeclaration:
767 llvm_unreachable("Should not have been asked to emit this");
771 // -fapple-kext mode does not support weak linkage, so we must use
773 if (Context.getLangOpts().AppleKext)
774 return llvm::Function::InternalLinkage;
776 llvm::GlobalVariable::LinkageTypes DiscardableODRLinkage =
777 llvm::GlobalValue::LinkOnceODRLinkage;
778 llvm::GlobalVariable::LinkageTypes NonDiscardableODRLinkage =
779 llvm::GlobalValue::WeakODRLinkage;
780 if (RD->hasAttr<DLLExportAttr>()) {
781 // Cannot discard exported vtables.
782 DiscardableODRLinkage = NonDiscardableODRLinkage;
783 } else if (RD->hasAttr<DLLImportAttr>()) {
784 // Imported vtables are available externally.
785 DiscardableODRLinkage = llvm::GlobalVariable::AvailableExternallyLinkage;
786 NonDiscardableODRLinkage = llvm::GlobalVariable::AvailableExternallyLinkage;
789 switch (RD->getTemplateSpecializationKind()) {
791 case TSK_ExplicitSpecialization:
792 case TSK_ImplicitInstantiation:
793 return DiscardableODRLinkage;
795 case TSK_ExplicitInstantiationDeclaration:
796 return shouldEmitAvailableExternallyVTable(*this, RD)
797 ? llvm::GlobalVariable::AvailableExternallyLinkage
798 : llvm::GlobalVariable::ExternalLinkage;
800 case TSK_ExplicitInstantiationDefinition:
801 return NonDiscardableODRLinkage;
804 llvm_unreachable("Invalid TemplateSpecializationKind!");
807 /// This is a callback from Sema to tell us that that a particular v-table is
808 /// required to be emitted in this translation unit.
810 /// This is only called for vtables that _must_ be emitted (mainly due to key
811 /// functions). For weak vtables, CodeGen tracks when they are needed and
812 /// emits them as-needed.
813 void CodeGenModule::EmitVTable(CXXRecordDecl *theClass) {
814 VTables.GenerateClassData(theClass);
818 CodeGenVTables::GenerateClassData(const CXXRecordDecl *RD) {
819 if (CGDebugInfo *DI = CGM.getModuleDebugInfo())
820 DI->completeClassData(RD);
822 if (RD->getNumVBases())
823 CGM.getCXXABI().emitVirtualInheritanceTables(RD);
825 CGM.getCXXABI().emitVTableDefinitions(*this, RD);
828 /// At this point in the translation unit, does it appear that can we
829 /// rely on the vtable being defined elsewhere in the program?
831 /// The response is really only definitive when called at the end of
832 /// the translation unit.
834 /// The only semantic restriction here is that the object file should
835 /// not contain a v-table definition when that v-table is defined
836 /// strongly elsewhere. Otherwise, we'd just like to avoid emitting
837 /// v-tables when unnecessary.
838 bool CodeGenVTables::isVTableExternal(const CXXRecordDecl *RD) {
839 assert(RD->isDynamicClass() && "Non-dynamic classes have no VTable.");
841 // If we have an explicit instantiation declaration (and not a
842 // definition), the v-table is defined elsewhere.
843 TemplateSpecializationKind TSK = RD->getTemplateSpecializationKind();
844 if (TSK == TSK_ExplicitInstantiationDeclaration)
847 // Otherwise, if the class is an instantiated template, the
848 // v-table must be defined here.
849 if (TSK == TSK_ImplicitInstantiation ||
850 TSK == TSK_ExplicitInstantiationDefinition)
853 // Otherwise, if the class doesn't have a key function (possibly
854 // anymore), the v-table must be defined here.
855 const CXXMethodDecl *keyFunction = CGM.getContext().getCurrentKeyFunction(RD);
859 // Otherwise, if we don't have a definition of the key function, the
860 // v-table must be defined somewhere else.
861 return !keyFunction->hasBody();
864 /// Given that we're currently at the end of the translation unit, and
865 /// we've emitted a reference to the v-table for this class, should
866 /// we define that v-table?
867 static bool shouldEmitVTableAtEndOfTranslationUnit(CodeGenModule &CGM,
868 const CXXRecordDecl *RD) {
869 // If vtable is internal then it has to be done.
870 if (!CGM.getVTables().isVTableExternal(RD))
873 // If it's external then maybe we will need it as available_externally.
874 return shouldEmitAvailableExternallyVTable(CGM, RD);
877 /// Given that at some point we emitted a reference to one or more
878 /// v-tables, and that we are now at the end of the translation unit,
879 /// decide whether we should emit them.
880 void CodeGenModule::EmitDeferredVTables() {
882 // Remember the size of DeferredVTables, because we're going to assume
883 // that this entire operation doesn't modify it.
884 size_t savedSize = DeferredVTables.size();
887 for (const CXXRecordDecl *RD : DeferredVTables)
888 if (shouldEmitVTableAtEndOfTranslationUnit(*this, RD))
889 VTables.GenerateClassData(RD);
891 assert(savedSize == DeferredVTables.size() &&
892 "deferred extra v-tables during v-table emission?");
893 DeferredVTables.clear();
896 bool CodeGenModule::IsCFIBlacklistedRecord(const CXXRecordDecl *RD) {
897 if (RD->hasAttr<UuidAttr>() &&
898 getContext().getSanitizerBlacklist().isBlacklistedType("attr:uuid"))
901 return getContext().getSanitizerBlacklist().isBlacklistedType(
902 RD->getQualifiedNameAsString());
905 void CodeGenModule::EmitVTableBitSetEntries(llvm::GlobalVariable *VTable,
906 const VTableLayout &VTLayout) {
907 if (!LangOpts.Sanitize.has(SanitizerKind::CFIVCall) &&
908 !LangOpts.Sanitize.has(SanitizerKind::CFINVCall) &&
909 !LangOpts.Sanitize.has(SanitizerKind::CFIDerivedCast) &&
910 !LangOpts.Sanitize.has(SanitizerKind::CFIUnrelatedCast))
913 CharUnits PointerWidth =
914 Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0));
916 typedef std::pair<const CXXRecordDecl *, unsigned> BSEntry;
917 std::vector<BSEntry> BitsetEntries;
918 // Create a bit set entry for each address point.
919 for (auto &&AP : VTLayout.getAddressPoints()) {
920 if (IsCFIBlacklistedRecord(AP.first.getBase()))
923 BitsetEntries.push_back(std::make_pair(AP.first.getBase(), AP.second));
926 // Sort the bit set entries for determinism.
927 std::sort(BitsetEntries.begin(), BitsetEntries.end(),
928 [this](const BSEntry &E1, const BSEntry &E2) {
933 llvm::raw_string_ostream O1(S1);
934 getCXXABI().getMangleContext().mangleTypeName(
935 QualType(E1.first->getTypeForDecl(), 0), O1);
939 llvm::raw_string_ostream O2(S2);
940 getCXXABI().getMangleContext().mangleTypeName(
941 QualType(E2.first->getTypeForDecl(), 0), O2);
949 return E1.second < E2.second;
952 llvm::NamedMDNode *BitsetsMD =
953 getModule().getOrInsertNamedMetadata("llvm.bitsets");
954 for (auto BitsetEntry : BitsetEntries)
955 CreateVTableBitSetEntry(BitsetsMD, VTable,
956 PointerWidth * BitsetEntry.second,