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/Frontend/CodeGenOptions.h"
20 #include "llvm/ADT/DenseSet.h"
21 #include "llvm/ADT/SetVector.h"
22 #include "llvm/Support/Compiler.h"
23 #include "llvm/Support/Format.h"
24 #include "llvm/Transforms/Utils/Cloning.h"
28 using namespace clang;
29 using namespace CodeGen;
31 CodeGenVTables::CodeGenVTables(CodeGenModule &CGM)
32 : CGM(CGM), VTContext(CGM.getContext()) { }
34 llvm::Constant *CodeGenModule::GetAddrOfThunk(GlobalDecl GD,
35 const ThunkInfo &Thunk) {
36 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
38 // Compute the mangled name.
39 SmallString<256> Name;
40 llvm::raw_svector_ostream Out(Name);
41 if (const CXXDestructorDecl* DD = dyn_cast<CXXDestructorDecl>(MD))
42 getCXXABI().getMangleContext().mangleCXXDtorThunk(DD, GD.getDtorType(),
45 getCXXABI().getMangleContext().mangleThunk(MD, Thunk, Out);
48 llvm::Type *Ty = getTypes().GetFunctionTypeForVTable(GD);
49 return GetOrCreateLLVMFunction(Name, Ty, GD, /*ForVTable=*/true);
52 static llvm::Value *PerformTypeAdjustment(CodeGenFunction &CGF,
54 int64_t NonVirtualAdjustment,
55 int64_t VirtualAdjustment,
56 bool IsReturnAdjustment) {
57 if (!NonVirtualAdjustment && !VirtualAdjustment)
60 llvm::Type *Int8PtrTy = CGF.Int8PtrTy;
61 llvm::Value *V = CGF.Builder.CreateBitCast(Ptr, Int8PtrTy);
63 if (NonVirtualAdjustment && !IsReturnAdjustment) {
64 // Perform the non-virtual adjustment for a base-to-derived cast.
65 V = CGF.Builder.CreateConstInBoundsGEP1_64(V, NonVirtualAdjustment);
68 if (VirtualAdjustment) {
69 llvm::Type *PtrDiffTy =
70 CGF.ConvertType(CGF.getContext().getPointerDiffType());
72 // Perform the virtual adjustment.
73 llvm::Value *VTablePtrPtr =
74 CGF.Builder.CreateBitCast(V, Int8PtrTy->getPointerTo());
76 llvm::Value *VTablePtr = CGF.Builder.CreateLoad(VTablePtrPtr);
78 llvm::Value *OffsetPtr =
79 CGF.Builder.CreateConstInBoundsGEP1_64(VTablePtr, VirtualAdjustment);
81 OffsetPtr = CGF.Builder.CreateBitCast(OffsetPtr, PtrDiffTy->getPointerTo());
83 // Load the adjustment offset from the vtable.
84 llvm::Value *Offset = CGF.Builder.CreateLoad(OffsetPtr);
86 // Adjust our pointer.
87 V = CGF.Builder.CreateInBoundsGEP(V, Offset);
90 if (NonVirtualAdjustment && IsReturnAdjustment) {
91 // Perform the non-virtual adjustment for a derived-to-base cast.
92 V = CGF.Builder.CreateConstInBoundsGEP1_64(V, NonVirtualAdjustment);
95 // Cast back to the original type.
96 return CGF.Builder.CreateBitCast(V, Ptr->getType());
99 static void setThunkVisibility(CodeGenModule &CGM, const CXXMethodDecl *MD,
100 const ThunkInfo &Thunk, llvm::Function *Fn) {
101 CGM.setGlobalVisibility(Fn, MD);
103 if (!CGM.getCodeGenOpts().HiddenWeakVTables)
106 // If the thunk has weak/linkonce linkage, but the function must be
107 // emitted in every translation unit that references it, then we can
108 // emit its thunks with hidden visibility, since its thunks must be
109 // emitted when the function is.
111 // This follows CodeGenModule::setTypeVisibility; see the comments
112 // there for explanation.
114 if ((Fn->getLinkage() != llvm::GlobalVariable::LinkOnceODRLinkage &&
115 Fn->getLinkage() != llvm::GlobalVariable::WeakODRLinkage) ||
116 Fn->getVisibility() != llvm::GlobalVariable::DefaultVisibility)
119 if (MD->getExplicitVisibility(ValueDecl::VisibilityForValue))
122 switch (MD->getTemplateSpecializationKind()) {
123 case TSK_ExplicitInstantiationDefinition:
124 case TSK_ExplicitInstantiationDeclaration:
130 case TSK_ExplicitSpecialization:
131 case TSK_ImplicitInstantiation:
136 // If there's an explicit definition, and that definition is
137 // out-of-line, then we can't assume that all users will have a
138 // definition to emit.
139 const FunctionDecl *Def = 0;
140 if (MD->hasBody(Def) && Def->isOutOfLine())
143 Fn->setVisibility(llvm::GlobalValue::HiddenVisibility);
147 static bool similar(const ABIArgInfo &infoL, CanQualType typeL,
148 const ABIArgInfo &infoR, CanQualType typeR) {
149 return (infoL.getKind() == infoR.getKind() &&
151 (isa<PointerType>(typeL) && isa<PointerType>(typeR)) ||
152 (isa<ReferenceType>(typeL) && isa<ReferenceType>(typeR))));
156 static RValue PerformReturnAdjustment(CodeGenFunction &CGF,
157 QualType ResultType, RValue RV,
158 const ThunkInfo &Thunk) {
159 // Emit the return adjustment.
160 bool NullCheckValue = !ResultType->isReferenceType();
162 llvm::BasicBlock *AdjustNull = 0;
163 llvm::BasicBlock *AdjustNotNull = 0;
164 llvm::BasicBlock *AdjustEnd = 0;
166 llvm::Value *ReturnValue = RV.getScalarVal();
168 if (NullCheckValue) {
169 AdjustNull = CGF.createBasicBlock("adjust.null");
170 AdjustNotNull = CGF.createBasicBlock("adjust.notnull");
171 AdjustEnd = CGF.createBasicBlock("adjust.end");
173 llvm::Value *IsNull = CGF.Builder.CreateIsNull(ReturnValue);
174 CGF.Builder.CreateCondBr(IsNull, AdjustNull, AdjustNotNull);
175 CGF.EmitBlock(AdjustNotNull);
178 ReturnValue = PerformTypeAdjustment(CGF, ReturnValue,
179 Thunk.Return.NonVirtual,
180 Thunk.Return.VBaseOffsetOffset,
181 /*IsReturnAdjustment*/true);
183 if (NullCheckValue) {
184 CGF.Builder.CreateBr(AdjustEnd);
185 CGF.EmitBlock(AdjustNull);
186 CGF.Builder.CreateBr(AdjustEnd);
187 CGF.EmitBlock(AdjustEnd);
189 llvm::PHINode *PHI = CGF.Builder.CreatePHI(ReturnValue->getType(), 2);
190 PHI->addIncoming(ReturnValue, AdjustNotNull);
191 PHI->addIncoming(llvm::Constant::getNullValue(ReturnValue->getType()),
196 return RValue::get(ReturnValue);
199 // This function does roughly the same thing as GenerateThunk, but in a
200 // very different way, so that va_start and va_end work correctly.
201 // FIXME: This function assumes "this" is the first non-sret LLVM argument of
202 // a function, and that there is an alloca built in the entry block
203 // for all accesses to "this".
204 // FIXME: This function assumes there is only one "ret" statement per function.
205 // FIXME: Cloning isn't correct in the presence of indirect goto!
206 // FIXME: This implementation of thunks bloats codesize by duplicating the
207 // function definition. There are alternatives:
208 // 1. Add some sort of stub support to LLVM for cases where we can
209 // do a this adjustment, then a sibcall.
210 // 2. We could transform the definition to take a va_list instead of an
211 // actual variable argument list, then have the thunks (including a
212 // no-op thunk for the regular definition) call va_start/va_end.
213 // There's a bit of per-call overhead for this solution, but it's
214 // better for codesize if the definition is long.
215 void CodeGenFunction::GenerateVarArgsThunk(
217 const CGFunctionInfo &FnInfo,
218 GlobalDecl GD, const ThunkInfo &Thunk) {
219 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
220 const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
221 QualType ResultType = FPT->getResultType();
223 // Get the original function
224 assert(FnInfo.isVariadic());
225 llvm::Type *Ty = CGM.getTypes().GetFunctionType(FnInfo);
226 llvm::Value *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true);
227 llvm::Function *BaseFn = cast<llvm::Function>(Callee);
230 llvm::ValueToValueMapTy VMap;
231 llvm::Function *NewFn = llvm::CloneFunction(BaseFn, VMap,
232 /*ModuleLevelChanges=*/false);
233 CGM.getModule().getFunctionList().push_back(NewFn);
234 Fn->replaceAllUsesWith(NewFn);
236 Fn->eraseFromParent();
239 // "Initialize" CGF (minimally).
242 // Get the "this" value
243 llvm::Function::arg_iterator AI = Fn->arg_begin();
244 if (CGM.ReturnTypeUsesSRet(FnInfo))
247 // Find the first store of "this", which will be to the alloca associated
249 llvm::Value *ThisPtr = &*AI;
250 llvm::BasicBlock *EntryBB = Fn->begin();
251 llvm::Instruction *ThisStore = 0;
252 for (llvm::BasicBlock::iterator I = EntryBB->begin(), E = EntryBB->end();
254 if (isa<llvm::StoreInst>(I) && I->getOperand(0) == ThisPtr) {
255 ThisStore = cast<llvm::StoreInst>(I);
259 assert(ThisStore && "Store of this should be in entry block?");
260 // Adjust "this", if necessary.
261 Builder.SetInsertPoint(ThisStore);
262 llvm::Value *AdjustedThisPtr =
263 PerformTypeAdjustment(*this, ThisPtr,
264 Thunk.This.NonVirtual,
265 Thunk.This.VCallOffsetOffset,
266 /*IsReturnAdjustment*/false);
267 ThisStore->setOperand(0, AdjustedThisPtr);
269 if (!Thunk.Return.isEmpty()) {
270 // Fix up the returned value, if necessary.
271 for (llvm::Function::iterator I = Fn->begin(), E = Fn->end(); I != E; I++) {
272 llvm::Instruction *T = I->getTerminator();
273 if (isa<llvm::ReturnInst>(T)) {
274 RValue RV = RValue::get(T->getOperand(0));
275 T->eraseFromParent();
276 Builder.SetInsertPoint(&*I);
277 RV = PerformReturnAdjustment(*this, ResultType, RV, Thunk);
278 Builder.CreateRet(RV.getScalarVal());
285 void CodeGenFunction::GenerateThunk(llvm::Function *Fn,
286 const CGFunctionInfo &FnInfo,
287 GlobalDecl GD, const ThunkInfo &Thunk) {
288 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
289 const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
290 QualType ResultType = FPT->getResultType();
291 QualType ThisType = MD->getThisType(getContext());
293 FunctionArgList FunctionArgs;
295 // FIXME: It would be nice if more of this code could be shared with
296 // CodeGenFunction::GenerateCode.
298 // Create the implicit 'this' parameter declaration.
300 CGM.getCXXABI().BuildInstanceFunctionParams(*this, ResultType, FunctionArgs);
302 // Add the rest of the parameters.
303 for (FunctionDecl::param_const_iterator I = MD->param_begin(),
304 E = MD->param_end(); I != E; ++I) {
305 ParmVarDecl *Param = *I;
307 FunctionArgs.push_back(Param);
310 // Initialize debug info if needed.
311 maybeInitializeDebugInfo();
313 StartFunction(GlobalDecl(), ResultType, Fn, FnInfo, FunctionArgs,
316 CGM.getCXXABI().EmitInstanceFunctionProlog(*this);
317 CXXThisValue = CXXABIThisValue;
319 // Adjust the 'this' pointer if necessary.
320 llvm::Value *AdjustedThisPtr =
321 PerformTypeAdjustment(*this, LoadCXXThis(),
322 Thunk.This.NonVirtual,
323 Thunk.This.VCallOffsetOffset,
324 /*IsReturnAdjustment*/false);
326 CallArgList CallArgs;
328 // Add our adjusted 'this' pointer.
329 CallArgs.add(RValue::get(AdjustedThisPtr), ThisType);
331 // Add the rest of the parameters.
332 for (FunctionDecl::param_const_iterator I = MD->param_begin(),
333 E = MD->param_end(); I != E; ++I) {
334 ParmVarDecl *param = *I;
335 EmitDelegateCallArg(CallArgs, param);
340 CGM.getTypes().GetFunctionType(CGM.getTypes().arrangeGlobalDeclaration(GD));
341 llvm::Value *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true);
344 const CGFunctionInfo &CallFnInfo =
345 CGM.getTypes().arrangeCXXMethodCall(CallArgs, FPT,
346 RequiredArgs::forPrototypePlus(FPT, 1));
347 assert(CallFnInfo.getRegParm() == FnInfo.getRegParm() &&
348 CallFnInfo.isNoReturn() == FnInfo.isNoReturn() &&
349 CallFnInfo.getCallingConvention() == FnInfo.getCallingConvention());
350 assert(isa<CXXDestructorDecl>(MD) || // ignore dtor return types
351 similar(CallFnInfo.getReturnInfo(), CallFnInfo.getReturnType(),
352 FnInfo.getReturnInfo(), FnInfo.getReturnType()));
353 assert(CallFnInfo.arg_size() == FnInfo.arg_size());
354 for (unsigned i = 0, e = FnInfo.arg_size(); i != e; ++i)
355 assert(similar(CallFnInfo.arg_begin()[i].info,
356 CallFnInfo.arg_begin()[i].type,
357 FnInfo.arg_begin()[i].info, FnInfo.arg_begin()[i].type));
360 // Determine whether we have a return value slot to use.
361 ReturnValueSlot Slot;
362 if (!ResultType->isVoidType() &&
363 FnInfo.getReturnInfo().getKind() == ABIArgInfo::Indirect &&
364 !hasScalarEvaluationKind(CurFnInfo->getReturnType()))
365 Slot = ReturnValueSlot(ReturnValue, ResultType.isVolatileQualified());
367 // Now emit our call.
368 RValue RV = EmitCall(FnInfo, Callee, Slot, CallArgs, MD);
370 if (!Thunk.Return.isEmpty())
371 RV = PerformReturnAdjustment(*this, ResultType, RV, Thunk);
373 if (!ResultType->isVoidType() && Slot.isNull())
374 CGM.getCXXABI().EmitReturnFromThunk(*this, RV, ResultType);
376 // Disable the final ARC autorelease.
377 AutoreleaseResult = false;
381 // Set the right linkage.
382 CGM.setFunctionLinkage(MD, Fn);
384 // Set the right visibility.
385 setThunkVisibility(CGM, MD, Thunk, Fn);
388 void CodeGenVTables::EmitThunk(GlobalDecl GD, const ThunkInfo &Thunk,
389 bool UseAvailableExternallyLinkage)
391 const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeGlobalDeclaration(GD);
393 // FIXME: re-use FnInfo in this computation.
394 llvm::Constant *Entry = CGM.GetAddrOfThunk(GD, Thunk);
396 // Strip off a bitcast if we got one back.
397 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
398 assert(CE->getOpcode() == llvm::Instruction::BitCast);
399 Entry = CE->getOperand(0);
402 // There's already a declaration with the same name, check if it has the same
403 // type or if we need to replace it.
404 if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() !=
405 CGM.getTypes().GetFunctionTypeForVTable(GD)) {
406 llvm::GlobalValue *OldThunkFn = cast<llvm::GlobalValue>(Entry);
408 // If the types mismatch then we have to rewrite the definition.
409 assert(OldThunkFn->isDeclaration() &&
410 "Shouldn't replace non-declaration");
412 // Remove the name from the old thunk function and get a new thunk.
413 OldThunkFn->setName(StringRef());
414 Entry = CGM.GetAddrOfThunk(GD, Thunk);
416 // If needed, replace the old thunk with a bitcast.
417 if (!OldThunkFn->use_empty()) {
418 llvm::Constant *NewPtrForOldDecl =
419 llvm::ConstantExpr::getBitCast(Entry, OldThunkFn->getType());
420 OldThunkFn->replaceAllUsesWith(NewPtrForOldDecl);
423 // Remove the old thunk.
424 OldThunkFn->eraseFromParent();
427 llvm::Function *ThunkFn = cast<llvm::Function>(Entry);
429 if (!ThunkFn->isDeclaration()) {
430 if (UseAvailableExternallyLinkage) {
431 // There is already a thunk emitted for this function, do nothing.
435 // If a function has a body, it should have available_externally linkage.
436 assert(ThunkFn->hasAvailableExternallyLinkage() &&
437 "Function should have available_externally linkage!");
439 // Change the linkage.
440 CGM.setFunctionLinkage(cast<CXXMethodDecl>(GD.getDecl()), ThunkFn);
444 CGM.SetLLVMFunctionAttributesForDefinition(GD.getDecl(), ThunkFn);
446 if (ThunkFn->isVarArg()) {
447 // Varargs thunks are special; we can't just generate a call because
448 // we can't copy the varargs. Our implementation is rather
449 // expensive/sucky at the moment, so don't generate the thunk unless
451 // FIXME: Do something better here; GenerateVarArgsThunk is extremely ugly.
452 if (!UseAvailableExternallyLinkage)
453 CodeGenFunction(CGM).GenerateVarArgsThunk(ThunkFn, FnInfo, GD, Thunk);
455 // Normal thunk body generation.
456 CodeGenFunction(CGM).GenerateThunk(ThunkFn, FnInfo, GD, Thunk);
459 if (UseAvailableExternallyLinkage)
460 ThunkFn->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
463 void CodeGenVTables::MaybeEmitThunkAvailableExternally(GlobalDecl GD,
464 const ThunkInfo &Thunk) {
465 // We only want to do this when building with optimizations.
466 if (!CGM.getCodeGenOpts().OptimizationLevel)
469 // We can't emit thunks for member functions with incomplete types.
470 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
471 if (!CGM.getTypes().isFuncTypeConvertible(
472 cast<FunctionType>(MD->getType().getTypePtr())))
475 EmitThunk(GD, Thunk, /*UseAvailableExternallyLinkage=*/true);
478 void CodeGenVTables::EmitThunks(GlobalDecl GD)
480 const CXXMethodDecl *MD =
481 cast<CXXMethodDecl>(GD.getDecl())->getCanonicalDecl();
483 // We don't need to generate thunks for the base destructor.
484 if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() == Dtor_Base)
487 const VTableContext::ThunkInfoVectorTy *ThunkInfoVector =
488 VTContext.getThunkInfo(MD);
489 if (!ThunkInfoVector)
492 for (unsigned I = 0, E = ThunkInfoVector->size(); I != E; ++I)
493 EmitThunk(GD, (*ThunkInfoVector)[I],
494 /*UseAvailableExternallyLinkage=*/false);
498 CodeGenVTables::CreateVTableInitializer(const CXXRecordDecl *RD,
499 const VTableComponent *Components,
500 unsigned NumComponents,
501 const VTableLayout::VTableThunkTy *VTableThunks,
502 unsigned NumVTableThunks) {
503 SmallVector<llvm::Constant *, 64> Inits;
505 llvm::Type *Int8PtrTy = CGM.Int8PtrTy;
507 llvm::Type *PtrDiffTy =
508 CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
510 QualType ClassType = CGM.getContext().getTagDeclType(RD);
511 llvm::Constant *RTTI = CGM.GetAddrOfRTTIDescriptor(ClassType);
513 unsigned NextVTableThunkIndex = 0;
515 llvm::Constant *PureVirtualFn = 0, *DeletedVirtualFn = 0;
517 for (unsigned I = 0; I != NumComponents; ++I) {
518 VTableComponent Component = Components[I];
520 llvm::Constant *Init = 0;
522 switch (Component.getKind()) {
523 case VTableComponent::CK_VCallOffset:
524 Init = llvm::ConstantInt::get(PtrDiffTy,
525 Component.getVCallOffset().getQuantity());
526 Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
528 case VTableComponent::CK_VBaseOffset:
529 Init = llvm::ConstantInt::get(PtrDiffTy,
530 Component.getVBaseOffset().getQuantity());
531 Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
533 case VTableComponent::CK_OffsetToTop:
534 Init = llvm::ConstantInt::get(PtrDiffTy,
535 Component.getOffsetToTop().getQuantity());
536 Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
538 case VTableComponent::CK_RTTI:
539 Init = llvm::ConstantExpr::getBitCast(RTTI, Int8PtrTy);
541 case VTableComponent::CK_FunctionPointer:
542 case VTableComponent::CK_CompleteDtorPointer:
543 case VTableComponent::CK_DeletingDtorPointer: {
546 // Get the right global decl.
547 switch (Component.getKind()) {
549 llvm_unreachable("Unexpected vtable component kind");
550 case VTableComponent::CK_FunctionPointer:
551 GD = Component.getFunctionDecl();
553 case VTableComponent::CK_CompleteDtorPointer:
554 GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Complete);
556 case VTableComponent::CK_DeletingDtorPointer:
557 GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Deleting);
561 if (cast<CXXMethodDecl>(GD.getDecl())->isPure()) {
562 // We have a pure virtual member function.
563 if (!PureVirtualFn) {
564 llvm::FunctionType *Ty =
565 llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
566 StringRef PureCallName = CGM.getCXXABI().GetPureVirtualCallName();
567 PureVirtualFn = CGM.CreateRuntimeFunction(Ty, PureCallName);
568 PureVirtualFn = llvm::ConstantExpr::getBitCast(PureVirtualFn,
571 Init = PureVirtualFn;
572 } else if (cast<CXXMethodDecl>(GD.getDecl())->isDeleted()) {
573 if (!DeletedVirtualFn) {
574 llvm::FunctionType *Ty =
575 llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
576 StringRef DeletedCallName =
577 CGM.getCXXABI().GetDeletedVirtualCallName();
578 DeletedVirtualFn = CGM.CreateRuntimeFunction(Ty, DeletedCallName);
579 DeletedVirtualFn = llvm::ConstantExpr::getBitCast(DeletedVirtualFn,
582 Init = DeletedVirtualFn;
584 // Check if we should use a thunk.
585 if (NextVTableThunkIndex < NumVTableThunks &&
586 VTableThunks[NextVTableThunkIndex].first == I) {
587 const ThunkInfo &Thunk = VTableThunks[NextVTableThunkIndex].second;
589 MaybeEmitThunkAvailableExternally(GD, Thunk);
590 Init = CGM.GetAddrOfThunk(GD, Thunk);
592 NextVTableThunkIndex++;
594 llvm::Type *Ty = CGM.getTypes().GetFunctionTypeForVTable(GD);
596 Init = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true);
599 Init = llvm::ConstantExpr::getBitCast(Init, Int8PtrTy);
604 case VTableComponent::CK_UnusedFunctionPointer:
605 Init = llvm::ConstantExpr::getNullValue(Int8PtrTy);
609 Inits.push_back(Init);
612 llvm::ArrayType *ArrayType = llvm::ArrayType::get(Int8PtrTy, NumComponents);
613 return llvm::ConstantArray::get(ArrayType, Inits);
616 llvm::GlobalVariable *CodeGenVTables::GetAddrOfVTable(const CXXRecordDecl *RD) {
617 llvm::GlobalVariable *&VTable = VTables[RD];
621 // Queue up this v-table for possible deferred emission.
622 CGM.addDeferredVTable(RD);
624 SmallString<256> OutName;
625 llvm::raw_svector_ostream Out(OutName);
626 CGM.getCXXABI().getMangleContext().mangleCXXVTable(RD, Out);
628 StringRef Name = OutName.str();
630 llvm::ArrayType *ArrayType =
631 llvm::ArrayType::get(CGM.Int8PtrTy,
632 VTContext.getVTableLayout(RD).getNumVTableComponents());
635 CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType,
636 llvm::GlobalValue::ExternalLinkage);
637 VTable->setUnnamedAddr(true);
642 CodeGenVTables::EmitVTableDefinition(llvm::GlobalVariable *VTable,
643 llvm::GlobalVariable::LinkageTypes Linkage,
644 const CXXRecordDecl *RD) {
645 const VTableLayout &VTLayout = VTContext.getVTableLayout(RD);
647 // Create and set the initializer.
648 llvm::Constant *Init =
649 CreateVTableInitializer(RD,
650 VTLayout.vtable_component_begin(),
651 VTLayout.getNumVTableComponents(),
652 VTLayout.vtable_thunk_begin(),
653 VTLayout.getNumVTableThunks());
654 VTable->setInitializer(Init);
656 // Set the correct linkage.
657 VTable->setLinkage(Linkage);
659 // Set the right visibility.
660 CGM.setTypeVisibility(VTable, RD, CodeGenModule::TVK_ForVTable);
663 llvm::GlobalVariable *
664 CodeGenVTables::GenerateConstructionVTable(const CXXRecordDecl *RD,
665 const BaseSubobject &Base,
667 llvm::GlobalVariable::LinkageTypes Linkage,
668 VTableAddressPointsMapTy& AddressPoints) {
669 OwningPtr<VTableLayout> VTLayout(
670 VTContext.createConstructionVTableLayout(Base.getBase(),
671 Base.getBaseOffset(),
674 // Add the address points.
675 AddressPoints = VTLayout->getAddressPoints();
677 // Get the mangled construction vtable name.
678 SmallString<256> OutName;
679 llvm::raw_svector_ostream Out(OutName);
680 CGM.getCXXABI().getMangleContext().
681 mangleCXXCtorVTable(RD, Base.getBaseOffset().getQuantity(), Base.getBase(),
684 StringRef Name = OutName.str();
686 llvm::ArrayType *ArrayType =
687 llvm::ArrayType::get(CGM.Int8PtrTy, VTLayout->getNumVTableComponents());
689 // Construction vtable symbols are not part of the Itanium ABI, so we cannot
690 // guarantee that they actually will be available externally. Instead, when
691 // emitting an available_externally VTT, we provide references to an internal
692 // linkage construction vtable. The ABI only requires complete-object vtables
693 // to be the same for all instances of a type, not construction vtables.
694 if (Linkage == llvm::GlobalVariable::AvailableExternallyLinkage)
695 Linkage = llvm::GlobalVariable::InternalLinkage;
697 // Create the variable that will hold the construction vtable.
698 llvm::GlobalVariable *VTable =
699 CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType, Linkage);
700 CGM.setTypeVisibility(VTable, RD, CodeGenModule::TVK_ForConstructionVTable);
702 // V-tables are always unnamed_addr.
703 VTable->setUnnamedAddr(true);
705 // Create and set the initializer.
706 llvm::Constant *Init =
707 CreateVTableInitializer(Base.getBase(),
708 VTLayout->vtable_component_begin(),
709 VTLayout->getNumVTableComponents(),
710 VTLayout->vtable_thunk_begin(),
711 VTLayout->getNumVTableThunks());
712 VTable->setInitializer(Init);
717 /// Compute the required linkage of the v-table for the given class.
719 /// Note that we only call this at the end of the translation unit.
720 llvm::GlobalVariable::LinkageTypes
721 CodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) {
722 if (RD->getLinkage() != ExternalLinkage)
723 return llvm::GlobalVariable::InternalLinkage;
725 // We're at the end of the translation unit, so the current key
726 // function is fully correct.
727 if (const CXXMethodDecl *keyFunction = Context.getCurrentKeyFunction(RD)) {
728 // If this class has a key function, use that to determine the
729 // linkage of the vtable.
730 const FunctionDecl *def = 0;
731 if (keyFunction->hasBody(def))
732 keyFunction = cast<CXXMethodDecl>(def);
734 switch (keyFunction->getTemplateSpecializationKind()) {
736 case TSK_ExplicitSpecialization:
737 // When compiling with optimizations turned on, we emit all vtables,
738 // even if the key function is not defined in the current translation
739 // unit. If this is the case, use available_externally linkage.
740 if (!def && CodeGenOpts.OptimizationLevel)
741 return llvm::GlobalVariable::AvailableExternallyLinkage;
743 if (keyFunction->isInlined())
744 return !Context.getLangOpts().AppleKext ?
745 llvm::GlobalVariable::LinkOnceODRLinkage :
746 llvm::Function::InternalLinkage;
748 return llvm::GlobalVariable::ExternalLinkage;
750 case TSK_ImplicitInstantiation:
751 return !Context.getLangOpts().AppleKext ?
752 llvm::GlobalVariable::LinkOnceODRLinkage :
753 llvm::Function::InternalLinkage;
755 case TSK_ExplicitInstantiationDefinition:
756 return !Context.getLangOpts().AppleKext ?
757 llvm::GlobalVariable::WeakODRLinkage :
758 llvm::Function::InternalLinkage;
760 case TSK_ExplicitInstantiationDeclaration:
761 return !Context.getLangOpts().AppleKext ?
762 llvm::GlobalVariable::AvailableExternallyLinkage :
763 llvm::Function::InternalLinkage;
767 // -fapple-kext mode does not support weak linkage, so we must use
769 if (Context.getLangOpts().AppleKext)
770 return llvm::Function::InternalLinkage;
772 switch (RD->getTemplateSpecializationKind()) {
774 case TSK_ExplicitSpecialization:
775 case TSK_ImplicitInstantiation:
776 return llvm::GlobalVariable::LinkOnceODRLinkage;
778 case TSK_ExplicitInstantiationDeclaration:
779 return llvm::GlobalVariable::AvailableExternallyLinkage;
781 case TSK_ExplicitInstantiationDefinition:
782 return llvm::GlobalVariable::WeakODRLinkage;
785 llvm_unreachable("Invalid TemplateSpecializationKind!");
788 /// This is a callback from Sema to tell us that it believes that a
789 /// particular v-table is required to be emitted in this translation
792 /// The reason we don't simply trust this callback is because Sema
793 /// will happily report that something is used even when it's used
794 /// only in code that we don't actually have to emit.
796 /// \param isRequired - if true, the v-table is mandatory, e.g.
797 /// because the translation unit defines the key function
798 void CodeGenModule::EmitVTable(CXXRecordDecl *theClass, bool isRequired) {
799 if (!isRequired) return;
801 VTables.GenerateClassData(theClass);
805 CodeGenVTables::GenerateClassData(const CXXRecordDecl *RD) {
806 // First off, check whether we've already emitted the v-table and
808 llvm::GlobalVariable *VTable = GetAddrOfVTable(RD);
809 if (VTable->hasInitializer())
812 llvm::GlobalVariable::LinkageTypes Linkage = CGM.getVTableLinkage(RD);
813 EmitVTableDefinition(VTable, Linkage, RD);
815 if (RD->getNumVBases()) {
816 if (!CGM.getTarget().getCXXABI().isMicrosoft()) {
817 llvm::GlobalVariable *VTT = GetAddrOfVTT(RD);
818 EmitVTTDefinition(VTT, Linkage, RD);
820 // FIXME: Emit vbtables here.
824 // If this is the magic class __cxxabiv1::__fundamental_type_info,
825 // we will emit the typeinfo for the fundamental types. This is the
826 // same behaviour as GCC.
827 const DeclContext *DC = RD->getDeclContext();
828 if (RD->getIdentifier() &&
829 RD->getIdentifier()->isStr("__fundamental_type_info") &&
830 isa<NamespaceDecl>(DC) &&
831 cast<NamespaceDecl>(DC)->getIdentifier() &&
832 cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__cxxabiv1") &&
833 DC->getParent()->isTranslationUnit())
834 CGM.EmitFundamentalRTTIDescriptors();
837 /// At this point in the translation unit, does it appear that can we
838 /// rely on the vtable being defined elsewhere in the program?
840 /// The response is really only definitive when called at the end of
841 /// the translation unit.
843 /// The only semantic restriction here is that the object file should
844 /// not contain a v-table definition when that v-table is defined
845 /// strongly elsewhere. Otherwise, we'd just like to avoid emitting
846 /// v-tables when unnecessary.
847 bool CodeGenVTables::isVTableExternal(const CXXRecordDecl *RD) {
848 assert(RD->isDynamicClass() && "Non dynamic classes have no VTable.");
850 // If we have an explicit instantiation declaration (and not a
851 // definition), the v-table is defined elsewhere.
852 TemplateSpecializationKind TSK = RD->getTemplateSpecializationKind();
853 if (TSK == TSK_ExplicitInstantiationDeclaration)
856 // Otherwise, if the class is an instantiated template, the
857 // v-table must be defined here.
858 if (TSK == TSK_ImplicitInstantiation ||
859 TSK == TSK_ExplicitInstantiationDefinition)
862 // Otherwise, if the class doesn't have a key function (possibly
863 // anymore), the v-table must be defined here.
864 const CXXMethodDecl *keyFunction = CGM.getContext().getCurrentKeyFunction(RD);
868 // Otherwise, if we don't have a definition of the key function, the
869 // v-table must be defined somewhere else.
870 return !keyFunction->hasBody();
873 /// Given that we're currently at the end of the translation unit, and
874 /// we've emitted a reference to the v-table for this class, should
875 /// we define that v-table?
876 static bool shouldEmitVTableAtEndOfTranslationUnit(CodeGenModule &CGM,
877 const CXXRecordDecl *RD) {
878 // If we're building with optimization, we always emit v-tables
879 // since that allows for virtual function calls to be devirtualized.
880 // If the v-table is defined strongly elsewhere, this definition
881 // will be emitted available_externally.
883 // However, we don't want to do this in -fapple-kext mode, because
884 // kext mode does not permit devirtualization.
885 if (CGM.getCodeGenOpts().OptimizationLevel && !CGM.getLangOpts().AppleKext)
888 return !CGM.getVTables().isVTableExternal(RD);
891 /// Given that at some point we emitted a reference to one or more
892 /// v-tables, and that we are now at the end of the translation unit,
893 /// decide whether we should emit them.
894 void CodeGenModule::EmitDeferredVTables() {
896 // Remember the size of DeferredVTables, because we're going to assume
897 // that this entire operation doesn't modify it.
898 size_t savedSize = DeferredVTables.size();
901 typedef std::vector<const CXXRecordDecl *>::const_iterator const_iterator;
902 for (const_iterator i = DeferredVTables.begin(),
903 e = DeferredVTables.end(); i != e; ++i) {
904 const CXXRecordDecl *RD = *i;
905 if (shouldEmitVTableAtEndOfTranslationUnit(*this, RD))
906 VTables.GenerateClassData(RD);
909 assert(savedSize == DeferredVTables.size() &&
910 "deferred extra v-tables during v-table emission?");
911 DeferredVTables.clear();