head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.11 netbsd-11-0-RC3:1.1.1.11 netbsd-11-0-RC2:1.1.1.11 netbsd-11-0-RC1:1.1.1.11 perseant-exfatfs-base-20250801:1.1.1.11 netbsd-11:1.1.1.11.0.10 netbsd-11-base:1.1.1.11 netbsd-10-1-RELEASE:1.1.1.11 perseant-exfatfs-base-20240630:1.1.1.11 perseant-exfatfs:1.1.1.11.0.8 perseant-exfatfs-base:1.1.1.11 netbsd-8-3-RELEASE:1.1.1.8 netbsd-9-4-RELEASE:1.1.1.10 netbsd-10-0-RELEASE:1.1.1.11 netbsd-10-0-RC6:1.1.1.11 netbsd-10-0-RC5:1.1.1.11 netbsd-10-0-RC4:1.1.1.11 netbsd-10-0-RC3:1.1.1.11 netbsd-10-0-RC2:1.1.1.11 netbsd-10-0-RC1:1.1.1.11 netbsd-10:1.1.1.11.0.6 netbsd-10-base:1.1.1.11 netbsd-9-3-RELEASE:1.1.1.10 cjep_sun2x:1.1.1.11.0.4 cjep_sun2x-base:1.1.1.11 cjep_staticlib_x-base1:1.1.1.11 netbsd-9-2-RELEASE:1.1.1.10 cjep_staticlib_x:1.1.1.11.0.2 cjep_staticlib_x-base:1.1.1.11 netbsd-9-1-RELEASE:1.1.1.10 phil-wifi-20200421:1.1.1.11 phil-wifi-20200411:1.1.1.11 phil-wifi-20200406:1.1.1.11 netbsd-8-2-RELEASE:1.1.1.8 netbsd-9-0-RELEASE:1.1.1.10 netbsd-9-0-RC2:1.1.1.10 netbsd-9-0-RC1:1.1.1.10 netbsd-9:1.1.1.10.0.2 netbsd-9-base:1.1.1.10 phil-wifi-20190609:1.1.1.10 netbsd-8-1-RELEASE:1.1.1.8 netbsd-8-1-RC1:1.1.1.8 pgoyette-compat-merge-20190127:1.1.1.9.2.1 pgoyette-compat-20190127:1.1.1.10 pgoyette-compat-20190118:1.1.1.10 pgoyette-compat-1226:1.1.1.10 pgoyette-compat-1126:1.1.1.10 pgoyette-compat-1020:1.1.1.10 pgoyette-compat-0930:1.1.1.10 pgoyette-compat-0906:1.1.1.10 netbsd-7-2-RELEASE:1.1.1.5.2.1 pgoyette-compat-0728:1.1.1.10 clang-337282:1.1.1.10 netbsd-8-0-RELEASE:1.1.1.8 phil-wifi:1.1.1.9.0.4 phil-wifi-base:1.1.1.9 pgoyette-compat-0625:1.1.1.9 netbsd-8-0-RC2:1.1.1.8 pgoyette-compat-0521:1.1.1.9 pgoyette-compat-0502:1.1.1.9 pgoyette-compat-0422:1.1.1.9 netbsd-8-0-RC1:1.1.1.8 pgoyette-compat-0415:1.1.1.9 pgoyette-compat-0407:1.1.1.9 pgoyette-compat-0330:1.1.1.9 pgoyette-compat-0322:1.1.1.9 pgoyette-compat-0315:1.1.1.9 netbsd-7-1-2-RELEASE:1.1.1.5.2.1 pgoyette-compat:1.1.1.9.0.2 pgoyette-compat-base:1.1.1.9 netbsd-7-1-1-RELEASE:1.1.1.5.2.1 clang-319952:1.1.1.9 matt-nb8-mediatek:1.1.1.8.0.10 matt-nb8-mediatek-base:1.1.1.8 clang-309604:1.1.1.9 perseant-stdc-iso10646:1.1.1.8.0.8 perseant-stdc-iso10646-base:1.1.1.8 netbsd-8:1.1.1.8.0.6 netbsd-8-base:1.1.1.8 prg-localcount2-base3:1.1.1.8 prg-localcount2-base2:1.1.1.8 prg-localcount2-base1:1.1.1.8 prg-localcount2:1.1.1.8.0.4 prg-localcount2-base:1.1.1.8 pgoyette-localcount-20170426:1.1.1.8 bouyer-socketcan-base1:1.1.1.8 pgoyette-localcount-20170320:1.1.1.8 netbsd-7-1:1.1.1.5.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.5.2.1 netbsd-7-1-RC2:1.1.1.5.2.1 clang-294123:1.1.1.8 netbsd-7-nhusb-base-20170116:1.1.1.5.2.1 bouyer-socketcan:1.1.1.8.0.2 bouyer-socketcan-base:1.1.1.8 clang-291444:1.1.1.8 pgoyette-localcount-20170107:1.1.1.7 netbsd-7-1-RC1:1.1.1.5.2.1 pgoyette-localcount-20161104:1.1.1.7 netbsd-7-0-2-RELEASE:1.1.1.5.2.1 localcount-20160914:1.1.1.7 netbsd-7-nhusb:1.1.1.5.2.1.0.4 netbsd-7-nhusb-base:1.1.1.5.2.1 clang-280599:1.1.1.7 pgoyette-localcount-20160806:1.1.1.7 pgoyette-localcount-20160726:1.1.1.7 pgoyette-localcount:1.1.1.7.0.2 pgoyette-localcount-base:1.1.1.7 netbsd-7-0-1-RELEASE:1.1.1.5.2.1 clang-261930:1.1.1.7 netbsd-7-0:1.1.1.5.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.5.2.1 netbsd-7-0-RC3:1.1.1.5.2.1 netbsd-7-0-RC2:1.1.1.5.2.1 netbsd-7-0-RC1:1.1.1.5.2.1 clang-237755:1.1.1.6 clang-232565:1.1.1.6 clang-227398:1.1.1.6 tls-maxphys-base:1.1.1.5 tls-maxphys:1.1.1.5.0.4 netbsd-7:1.1.1.5.0.2 netbsd-7-base:1.1.1.5 clang-215315:1.1.1.5 clang-209886:1.1.1.4 yamt-pagecache:1.1.1.3.0.4 yamt-pagecache-base9:1.1.1.3 tls-earlyentropy:1.1.1.3.0.2 tls-earlyentropy-base:1.1.1.4 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.3 riastradh-drm2-base3:1.1.1.3 clang-202566:1.1.1.3 clang-201163:1.1.1.3 clang-199312:1.1.1.2 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.53; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.53; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.38.14; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.02.14.20.07.10; author joerg; state Exp; branches 1.1.1.3.2.1 1.1.1.3.4.1; next 1.1.1.4; commitid annVkZ1sc17rF6px; 1.1.1.4 date 2014.05.30.18.14.41; author joerg; state Exp; branches; next 1.1.1.5; commitid 8q0kdlBlCn09GACx; 1.1.1.5 date 2014.08.10.17.08.35; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid N85tXAN6Ex9VZPLx; 1.1.1.6 date 2015.01.29.19.57.31; author joerg; state Exp; branches; next 1.1.1.7; commitid mlISSizlPKvepX7y; 1.1.1.7 date 2016.02.27.22.12.07; author joerg; state Exp; branches 1.1.1.7.2.1; next 1.1.1.8; commitid tIimz3oDlh1NpBWy; 1.1.1.8 date 2017.01.11.10.33.30; author joerg; state Exp; branches; next 1.1.1.9; commitid CNnUNfII1jgNmxBz; 1.1.1.9 date 2017.08.01.19.35.26; author joerg; state Exp; branches 1.1.1.9.2.1 1.1.1.9.4.1; next 1.1.1.10; commitid pMuDy65V0VicSx1A; 1.1.1.10 date 2018.07.17.18.30.59; author joerg; state Exp; branches; next 1.1.1.11; commitid wDzL46ALjrCZgwKA; 1.1.1.11 date 2019.11.13.22.19.21; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.3.2.1 date 2014.08.10.07.08.07; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.3.4.1 date 2014.02.14.20.07.10; author yamt; state dead; branches; next 1.1.1.3.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.3.4.2 date 2014.05.22.16.18.27; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.5.2.1 date 2015.06.04.20.04.28; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.5.4.1 date 2014.08.10.17.08.35; author tls; state dead; branches; next 1.1.1.5.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.5.4.2 date 2014.08.19.23.47.27; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.7.2.1 date 2017.03.20.06.52.37; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.9.2.1 date 2018.07.28.04.33.18; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.9.4.1 date 2019.06.10.21.45.21; author christos; state Exp; branches; next 1.1.1.9.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.9.4.2 date 2020.04.13.07.46.32; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- CGVTables.cpp - Emit LLVM Code for C++ vtables -------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This contains code dealing with C++ code generation of virtual tables. // //===----------------------------------------------------------------------===// #include "CodeGenFunction.h" #include "CGCXXABI.h" #include "CodeGenModule.h" #include "clang/AST/CXXInheritance.h" #include "clang/AST/RecordLayout.h" #include "clang/CodeGen/CGFunctionInfo.h" #include "clang/Frontend/CodeGenOptions.h" #include "llvm/ADT/DenseSet.h" #include "llvm/ADT/SetVector.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/Format.h" #include "llvm/Transforms/Utils/Cloning.h" #include #include using namespace clang; using namespace CodeGen; CodeGenVTables::CodeGenVTables(CodeGenModule &CGM) : CGM(CGM), ItaniumVTContext(CGM.getContext()) { if (CGM.getTarget().getCXXABI().isMicrosoft()) { // FIXME: Eventually, we should only have one of V*TContexts available. // Today we use both in the Microsoft ABI as MicrosoftVFTableContext // is not completely supported in CodeGen yet. MicrosoftVTContext.reset(new MicrosoftVTableContext(CGM.getContext())); } } llvm::Constant *CodeGenModule::GetAddrOfThunk(GlobalDecl GD, const ThunkInfo &Thunk) { const CXXMethodDecl *MD = cast(GD.getDecl()); // Compute the mangled name. SmallString<256> Name; llvm::raw_svector_ostream Out(Name); if (const CXXDestructorDecl* DD = dyn_cast(MD)) getCXXABI().getMangleContext().mangleCXXDtorThunk(DD, GD.getDtorType(), Thunk.This, Out); else getCXXABI().getMangleContext().mangleThunk(MD, Thunk, Out); Out.flush(); llvm::Type *Ty = getTypes().GetFunctionTypeForVTable(GD); return GetOrCreateLLVMFunction(Name, Ty, GD, /*ForVTable=*/true); } static void setThunkVisibility(CodeGenModule &CGM, const CXXMethodDecl *MD, const ThunkInfo &Thunk, llvm::Function *Fn) { CGM.setGlobalVisibility(Fn, MD); if (!CGM.getCodeGenOpts().HiddenWeakVTables) return; // If the thunk has weak/linkonce linkage, but the function must be // emitted in every translation unit that references it, then we can // emit its thunks with hidden visibility, since its thunks must be // emitted when the function is. // This follows CodeGenModule::setTypeVisibility; see the comments // there for explanation. if ((Fn->getLinkage() != llvm::GlobalVariable::LinkOnceODRLinkage && Fn->getLinkage() != llvm::GlobalVariable::WeakODRLinkage) || Fn->getVisibility() != llvm::GlobalVariable::DefaultVisibility) return; if (MD->getExplicitVisibility(ValueDecl::VisibilityForValue)) return; switch (MD->getTemplateSpecializationKind()) { case TSK_ExplicitInstantiationDefinition: case TSK_ExplicitInstantiationDeclaration: return; case TSK_Undeclared: break; case TSK_ExplicitSpecialization: case TSK_ImplicitInstantiation: return; break; } // If there's an explicit definition, and that definition is // out-of-line, then we can't assume that all users will have a // definition to emit. const FunctionDecl *Def = 0; if (MD->hasBody(Def) && Def->isOutOfLine()) return; Fn->setVisibility(llvm::GlobalValue::HiddenVisibility); } #ifndef NDEBUG static bool similar(const ABIArgInfo &infoL, CanQualType typeL, const ABIArgInfo &infoR, CanQualType typeR) { return (infoL.getKind() == infoR.getKind() && (typeL == typeR || (isa(typeL) && isa(typeR)) || (isa(typeL) && isa(typeR)))); } #endif static RValue PerformReturnAdjustment(CodeGenFunction &CGF, QualType ResultType, RValue RV, const ThunkInfo &Thunk) { // Emit the return adjustment. bool NullCheckValue = !ResultType->isReferenceType(); llvm::BasicBlock *AdjustNull = 0; llvm::BasicBlock *AdjustNotNull = 0; llvm::BasicBlock *AdjustEnd = 0; llvm::Value *ReturnValue = RV.getScalarVal(); if (NullCheckValue) { AdjustNull = CGF.createBasicBlock("adjust.null"); AdjustNotNull = CGF.createBasicBlock("adjust.notnull"); AdjustEnd = CGF.createBasicBlock("adjust.end"); llvm::Value *IsNull = CGF.Builder.CreateIsNull(ReturnValue); CGF.Builder.CreateCondBr(IsNull, AdjustNull, AdjustNotNull); CGF.EmitBlock(AdjustNotNull); } ReturnValue = CGF.CGM.getCXXABI().performReturnAdjustment(CGF, ReturnValue, Thunk.Return); if (NullCheckValue) { CGF.Builder.CreateBr(AdjustEnd); CGF.EmitBlock(AdjustNull); CGF.Builder.CreateBr(AdjustEnd); CGF.EmitBlock(AdjustEnd); llvm::PHINode *PHI = CGF.Builder.CreatePHI(ReturnValue->getType(), 2); PHI->addIncoming(ReturnValue, AdjustNotNull); PHI->addIncoming(llvm::Constant::getNullValue(ReturnValue->getType()), AdjustNull); ReturnValue = PHI; } return RValue::get(ReturnValue); } // This function does roughly the same thing as GenerateThunk, but in a // very different way, so that va_start and va_end work correctly. // FIXME: This function assumes "this" is the first non-sret LLVM argument of // a function, and that there is an alloca built in the entry block // for all accesses to "this". // FIXME: This function assumes there is only one "ret" statement per function. // FIXME: Cloning isn't correct in the presence of indirect goto! // FIXME: This implementation of thunks bloats codesize by duplicating the // function definition. There are alternatives: // 1. Add some sort of stub support to LLVM for cases where we can // do a this adjustment, then a sibcall. // 2. We could transform the definition to take a va_list instead of an // actual variable argument list, then have the thunks (including a // no-op thunk for the regular definition) call va_start/va_end. // There's a bit of per-call overhead for this solution, but it's // better for codesize if the definition is long. void CodeGenFunction::GenerateVarArgsThunk( llvm::Function *Fn, const CGFunctionInfo &FnInfo, GlobalDecl GD, const ThunkInfo &Thunk) { const CXXMethodDecl *MD = cast(GD.getDecl()); const FunctionProtoType *FPT = MD->getType()->getAs(); QualType ResultType = FPT->getResultType(); // Get the original function assert(FnInfo.isVariadic()); llvm::Type *Ty = CGM.getTypes().GetFunctionType(FnInfo); llvm::Value *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true); llvm::Function *BaseFn = cast(Callee); // Clone to thunk. llvm::ValueToValueMapTy VMap; llvm::Function *NewFn = llvm::CloneFunction(BaseFn, VMap, /*ModuleLevelChanges=*/false); CGM.getModule().getFunctionList().push_back(NewFn); Fn->replaceAllUsesWith(NewFn); NewFn->takeName(Fn); Fn->eraseFromParent(); Fn = NewFn; // "Initialize" CGF (minimally). CurFn = Fn; // Get the "this" value llvm::Function::arg_iterator AI = Fn->arg_begin(); if (CGM.ReturnTypeUsesSRet(FnInfo)) ++AI; // Find the first store of "this", which will be to the alloca associated // with "this". llvm::Value *ThisPtr = &*AI; llvm::BasicBlock *EntryBB = Fn->begin(); llvm::Instruction *ThisStore = 0; for (llvm::BasicBlock::iterator I = EntryBB->begin(), E = EntryBB->end(); I != E; I++) { if (isa(I) && I->getOperand(0) == ThisPtr) { ThisStore = cast(I); break; } } assert(ThisStore && "Store of this should be in entry block?"); // Adjust "this", if necessary. Builder.SetInsertPoint(ThisStore); llvm::Value *AdjustedThisPtr = CGM.getCXXABI().performThisAdjustment(*this, ThisPtr, Thunk.This); ThisStore->setOperand(0, AdjustedThisPtr); if (!Thunk.Return.isEmpty()) { // Fix up the returned value, if necessary. for (llvm::Function::iterator I = Fn->begin(), E = Fn->end(); I != E; I++) { llvm::Instruction *T = I->getTerminator(); if (isa(T)) { RValue RV = RValue::get(T->getOperand(0)); T->eraseFromParent(); Builder.SetInsertPoint(&*I); RV = PerformReturnAdjustment(*this, ResultType, RV, Thunk); Builder.CreateRet(RV.getScalarVal()); break; } } } } void CodeGenFunction::StartThunk(llvm::Function *Fn, GlobalDecl GD, const CGFunctionInfo &FnInfo) { assert(!CurGD.getDecl() && "CurGD was already set!"); CurGD = GD; // Build FunctionArgs. const CXXMethodDecl *MD = cast(GD.getDecl()); QualType ThisType = MD->getThisType(getContext()); const FunctionProtoType *FPT = MD->getType()->getAs(); QualType ResultType = CGM.getCXXABI().HasThisReturn(GD) ? ThisType : FPT->getResultType(); FunctionArgList FunctionArgs; // Create the implicit 'this' parameter declaration. CGM.getCXXABI().BuildInstanceFunctionParams(*this, ResultType, FunctionArgs); // Add the rest of the parameters. for (FunctionDecl::param_const_iterator I = MD->param_begin(), E = MD->param_end(); I != E; ++I) FunctionArgs.push_back(*I); // Start defining the function. StartFunction(GlobalDecl(), ResultType, Fn, FnInfo, FunctionArgs, SourceLocation()); // Since we didn't pass a GlobalDecl to StartFunction, do this ourselves. CGM.getCXXABI().EmitInstanceFunctionProlog(*this); CXXThisValue = CXXABIThisValue; } void CodeGenFunction::EmitCallAndReturnForThunk(GlobalDecl GD, llvm::Value *Callee, const ThunkInfo *Thunk) { assert(isa(CurGD.getDecl()) && "Please use a new CGF for this thunk"); const CXXMethodDecl *MD = cast(GD.getDecl()); // Adjust the 'this' pointer if necessary llvm::Value *AdjustedThisPtr = Thunk ? CGM.getCXXABI().performThisAdjustment( *this, LoadCXXThis(), Thunk->This) : LoadCXXThis(); // Start building CallArgs. CallArgList CallArgs; QualType ThisType = MD->getThisType(getContext()); CallArgs.add(RValue::get(AdjustedThisPtr), ThisType); if (isa(MD)) CGM.getCXXABI().adjustCallArgsForDestructorThunk(*this, GD, CallArgs); // Add the rest of the arguments. for (FunctionDecl::param_const_iterator I = MD->param_begin(), E = MD->param_end(); I != E; ++I) EmitDelegateCallArg(CallArgs, *I, (*I)->getLocStart()); const FunctionProtoType *FPT = MD->getType()->getAs(); #ifndef NDEBUG const CGFunctionInfo &CallFnInfo = CGM.getTypes().arrangeCXXMethodCall(CallArgs, FPT, RequiredArgs::forPrototypePlus(FPT, 1)); assert(CallFnInfo.getRegParm() == CurFnInfo->getRegParm() && CallFnInfo.isNoReturn() == CurFnInfo->isNoReturn() && CallFnInfo.getCallingConvention() == CurFnInfo->getCallingConvention()); assert(isa(MD) || // ignore dtor return types similar(CallFnInfo.getReturnInfo(), CallFnInfo.getReturnType(), CurFnInfo->getReturnInfo(), CurFnInfo->getReturnType())); assert(CallFnInfo.arg_size() == CurFnInfo->arg_size()); for (unsigned i = 0, e = CurFnInfo->arg_size(); i != e; ++i) assert(similar(CallFnInfo.arg_begin()[i].info, CallFnInfo.arg_begin()[i].type, CurFnInfo->arg_begin()[i].info, CurFnInfo->arg_begin()[i].type)); #endif // Determine whether we have a return value slot to use. QualType ResultType = CGM.getCXXABI().HasThisReturn(GD) ? ThisType : FPT->getResultType(); ReturnValueSlot Slot; if (!ResultType->isVoidType() && CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect && !hasScalarEvaluationKind(CurFnInfo->getReturnType())) Slot = ReturnValueSlot(ReturnValue, ResultType.isVolatileQualified()); // Now emit our call. RValue RV = EmitCall(*CurFnInfo, Callee, Slot, CallArgs, MD); // Consider return adjustment if we have ThunkInfo. if (Thunk && !Thunk->Return.isEmpty()) RV = PerformReturnAdjustment(*this, ResultType, RV, *Thunk); // Emit return. if (!ResultType->isVoidType() && Slot.isNull()) CGM.getCXXABI().EmitReturnFromThunk(*this, RV, ResultType); // Disable the final ARC autorelease. AutoreleaseResult = false; FinishFunction(); } void CodeGenFunction::GenerateThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo, GlobalDecl GD, const ThunkInfo &Thunk) { StartThunk(Fn, GD, FnInfo); // Get our callee. llvm::Type *Ty = CGM.getTypes().GetFunctionType(CGM.getTypes().arrangeGlobalDeclaration(GD)); llvm::Value *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true); // Make the call and return the result. EmitCallAndReturnForThunk(GD, Callee, &Thunk); // Set the right linkage. CGM.setFunctionLinkage(GD, Fn); // Set the right visibility. const CXXMethodDecl *MD = cast(GD.getDecl()); setThunkVisibility(CGM, MD, Thunk, Fn); } void CodeGenVTables::emitThunk(GlobalDecl GD, const ThunkInfo &Thunk, bool ForVTable) { const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeGlobalDeclaration(GD); // FIXME: re-use FnInfo in this computation. llvm::Constant *Entry = CGM.GetAddrOfThunk(GD, Thunk); // Strip off a bitcast if we got one back. if (llvm::ConstantExpr *CE = dyn_cast(Entry)) { assert(CE->getOpcode() == llvm::Instruction::BitCast); Entry = CE->getOperand(0); } // There's already a declaration with the same name, check if it has the same // type or if we need to replace it. if (cast(Entry)->getType()->getElementType() != CGM.getTypes().GetFunctionTypeForVTable(GD)) { llvm::GlobalValue *OldThunkFn = cast(Entry); // If the types mismatch then we have to rewrite the definition. assert(OldThunkFn->isDeclaration() && "Shouldn't replace non-declaration"); // Remove the name from the old thunk function and get a new thunk. OldThunkFn->setName(StringRef()); Entry = CGM.GetAddrOfThunk(GD, Thunk); // If needed, replace the old thunk with a bitcast. if (!OldThunkFn->use_empty()) { llvm::Constant *NewPtrForOldDecl = llvm::ConstantExpr::getBitCast(Entry, OldThunkFn->getType()); OldThunkFn->replaceAllUsesWith(NewPtrForOldDecl); } // Remove the old thunk. OldThunkFn->eraseFromParent(); } llvm::Function *ThunkFn = cast(Entry); bool ABIHasKeyFunctions = CGM.getTarget().getCXXABI().hasKeyFunctions(); bool UseAvailableExternallyLinkage = ForVTable && ABIHasKeyFunctions; if (!ThunkFn->isDeclaration()) { if (!ABIHasKeyFunctions || UseAvailableExternallyLinkage) { // There is already a thunk emitted for this function, do nothing. return; } // Change the linkage. CGM.setFunctionLinkage(GD, ThunkFn); return; } CGM.SetLLVMFunctionAttributesForDefinition(GD.getDecl(), ThunkFn); if (ThunkFn->isVarArg()) { // Varargs thunks are special; we can't just generate a call because // we can't copy the varargs. Our implementation is rather // expensive/sucky at the moment, so don't generate the thunk unless // we have to. // FIXME: Do something better here; GenerateVarArgsThunk is extremely ugly. if (!UseAvailableExternallyLinkage) CodeGenFunction(CGM).GenerateVarArgsThunk(ThunkFn, FnInfo, GD, Thunk); } else { // Normal thunk body generation. CodeGenFunction(CGM).GenerateThunk(ThunkFn, FnInfo, GD, Thunk); } CGM.getCXXABI().setThunkLinkage(ThunkFn, ForVTable); } void CodeGenVTables::maybeEmitThunkForVTable(GlobalDecl GD, const ThunkInfo &Thunk) { // If the ABI has key functions, only the TU with the key function should emit // the thunk. However, we can allow inlining of thunks if we emit them with // available_externally linkage together with vtables when optimizations are // enabled. if (CGM.getTarget().getCXXABI().hasKeyFunctions() && !CGM.getCodeGenOpts().OptimizationLevel) return; // We can't emit thunks for member functions with incomplete types. const CXXMethodDecl *MD = cast(GD.getDecl()); if (!CGM.getTypes().isFuncTypeConvertible( MD->getType()->castAs())) return; emitThunk(GD, Thunk, /*ForVTable=*/true); } void CodeGenVTables::EmitThunks(GlobalDecl GD) { const CXXMethodDecl *MD = cast(GD.getDecl())->getCanonicalDecl(); // We don't need to generate thunks for the base destructor. if (isa(MD) && GD.getDtorType() == Dtor_Base) return; const VTableContextBase::ThunkInfoVectorTy *ThunkInfoVector; if (MicrosoftVTContext.isValid()) { ThunkInfoVector = MicrosoftVTContext->getThunkInfo(GD); } else { ThunkInfoVector = ItaniumVTContext.getThunkInfo(GD); } if (!ThunkInfoVector) return; for (unsigned I = 0, E = ThunkInfoVector->size(); I != E; ++I) emitThunk(GD, (*ThunkInfoVector)[I], /*ForVTable=*/false); } llvm::Constant * CodeGenVTables::CreateVTableInitializer(const CXXRecordDecl *RD, const VTableComponent *Components, unsigned NumComponents, const VTableLayout::VTableThunkTy *VTableThunks, unsigned NumVTableThunks) { SmallVector Inits; llvm::Type *Int8PtrTy = CGM.Int8PtrTy; llvm::Type *PtrDiffTy = CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType()); QualType ClassType = CGM.getContext().getTagDeclType(RD); llvm::Constant *RTTI = CGM.GetAddrOfRTTIDescriptor(ClassType); unsigned NextVTableThunkIndex = 0; llvm::Constant *PureVirtualFn = 0, *DeletedVirtualFn = 0; for (unsigned I = 0; I != NumComponents; ++I) { VTableComponent Component = Components[I]; llvm::Constant *Init = 0; switch (Component.getKind()) { case VTableComponent::CK_VCallOffset: Init = llvm::ConstantInt::get(PtrDiffTy, Component.getVCallOffset().getQuantity()); Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy); break; case VTableComponent::CK_VBaseOffset: Init = llvm::ConstantInt::get(PtrDiffTy, Component.getVBaseOffset().getQuantity()); Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy); break; case VTableComponent::CK_OffsetToTop: Init = llvm::ConstantInt::get(PtrDiffTy, Component.getOffsetToTop().getQuantity()); Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy); break; case VTableComponent::CK_RTTI: Init = llvm::ConstantExpr::getBitCast(RTTI, Int8PtrTy); break; case VTableComponent::CK_FunctionPointer: case VTableComponent::CK_CompleteDtorPointer: case VTableComponent::CK_DeletingDtorPointer: { GlobalDecl GD; // Get the right global decl. switch (Component.getKind()) { default: llvm_unreachable("Unexpected vtable component kind"); case VTableComponent::CK_FunctionPointer: GD = Component.getFunctionDecl(); break; case VTableComponent::CK_CompleteDtorPointer: GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Complete); break; case VTableComponent::CK_DeletingDtorPointer: GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Deleting); break; } if (cast(GD.getDecl())->isPure()) { // We have a pure virtual member function. if (!PureVirtualFn) { llvm::FunctionType *Ty = llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false); StringRef PureCallName = CGM.getCXXABI().GetPureVirtualCallName(); PureVirtualFn = CGM.CreateRuntimeFunction(Ty, PureCallName); PureVirtualFn = llvm::ConstantExpr::getBitCast(PureVirtualFn, CGM.Int8PtrTy); } Init = PureVirtualFn; } else if (cast(GD.getDecl())->isDeleted()) { if (!DeletedVirtualFn) { llvm::FunctionType *Ty = llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false); StringRef DeletedCallName = CGM.getCXXABI().GetDeletedVirtualCallName(); DeletedVirtualFn = CGM.CreateRuntimeFunction(Ty, DeletedCallName); DeletedVirtualFn = llvm::ConstantExpr::getBitCast(DeletedVirtualFn, CGM.Int8PtrTy); } Init = DeletedVirtualFn; } else { // Check if we should use a thunk. if (NextVTableThunkIndex < NumVTableThunks && VTableThunks[NextVTableThunkIndex].first == I) { const ThunkInfo &Thunk = VTableThunks[NextVTableThunkIndex].second; maybeEmitThunkForVTable(GD, Thunk); Init = CGM.GetAddrOfThunk(GD, Thunk); NextVTableThunkIndex++; } else { llvm::Type *Ty = CGM.getTypes().GetFunctionTypeForVTable(GD); Init = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true); } Init = llvm::ConstantExpr::getBitCast(Init, Int8PtrTy); } break; } case VTableComponent::CK_UnusedFunctionPointer: Init = llvm::ConstantExpr::getNullValue(Int8PtrTy); break; }; Inits.push_back(Init); } llvm::ArrayType *ArrayType = llvm::ArrayType::get(Int8PtrTy, NumComponents); return llvm::ConstantArray::get(ArrayType, Inits); } llvm::GlobalVariable * CodeGenVTables::GenerateConstructionVTable(const CXXRecordDecl *RD, const BaseSubobject &Base, bool BaseIsVirtual, llvm::GlobalVariable::LinkageTypes Linkage, VTableAddressPointsMapTy& AddressPoints) { if (CGDebugInfo *DI = CGM.getModuleDebugInfo()) DI->completeClassData(Base.getBase()); OwningPtr VTLayout( ItaniumVTContext.createConstructionVTableLayout( Base.getBase(), Base.getBaseOffset(), BaseIsVirtual, RD)); // Add the address points. AddressPoints = VTLayout->getAddressPoints(); // Get the mangled construction vtable name. SmallString<256> OutName; llvm::raw_svector_ostream Out(OutName); cast(CGM.getCXXABI().getMangleContext()) .mangleCXXCtorVTable(RD, Base.getBaseOffset().getQuantity(), Base.getBase(), Out); Out.flush(); StringRef Name = OutName.str(); llvm::ArrayType *ArrayType = llvm::ArrayType::get(CGM.Int8PtrTy, VTLayout->getNumVTableComponents()); // Construction vtable symbols are not part of the Itanium ABI, so we cannot // guarantee that they actually will be available externally. Instead, when // emitting an available_externally VTT, we provide references to an internal // linkage construction vtable. The ABI only requires complete-object vtables // to be the same for all instances of a type, not construction vtables. if (Linkage == llvm::GlobalVariable::AvailableExternallyLinkage) Linkage = llvm::GlobalVariable::InternalLinkage; // Create the variable that will hold the construction vtable. llvm::GlobalVariable *VTable = CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType, Linkage); CGM.setTypeVisibility(VTable, RD, CodeGenModule::TVK_ForConstructionVTable); // V-tables are always unnamed_addr. VTable->setUnnamedAddr(true); // Create and set the initializer. llvm::Constant *Init = CreateVTableInitializer(Base.getBase(), VTLayout->vtable_component_begin(), VTLayout->getNumVTableComponents(), VTLayout->vtable_thunk_begin(), VTLayout->getNumVTableThunks()); VTable->setInitializer(Init); return VTable; } /// Compute the required linkage of the v-table for the given class. /// /// Note that we only call this at the end of the translation unit. llvm::GlobalVariable::LinkageTypes CodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) { if (!RD->isExternallyVisible()) return llvm::GlobalVariable::InternalLinkage; // We're at the end of the translation unit, so the current key // function is fully correct. if (const CXXMethodDecl *keyFunction = Context.getCurrentKeyFunction(RD)) { // If this class has a key function, use that to determine the // linkage of the vtable. const FunctionDecl *def = 0; if (keyFunction->hasBody(def)) keyFunction = cast(def); switch (keyFunction->getTemplateSpecializationKind()) { case TSK_Undeclared: case TSK_ExplicitSpecialization: assert(def && "Should not have been asked to emit this"); if (keyFunction->isInlined()) return !Context.getLangOpts().AppleKext ? llvm::GlobalVariable::LinkOnceODRLinkage : llvm::Function::InternalLinkage; return llvm::GlobalVariable::ExternalLinkage; case TSK_ImplicitInstantiation: return !Context.getLangOpts().AppleKext ? llvm::GlobalVariable::LinkOnceODRLinkage : llvm::Function::InternalLinkage; case TSK_ExplicitInstantiationDefinition: return !Context.getLangOpts().AppleKext ? llvm::GlobalVariable::WeakODRLinkage : llvm::Function::InternalLinkage; case TSK_ExplicitInstantiationDeclaration: llvm_unreachable("Should not have been asked to emit this"); } } // -fapple-kext mode does not support weak linkage, so we must use // internal linkage. if (Context.getLangOpts().AppleKext) return llvm::Function::InternalLinkage; switch (RD->getTemplateSpecializationKind()) { case TSK_Undeclared: case TSK_ExplicitSpecialization: case TSK_ImplicitInstantiation: return llvm::GlobalVariable::LinkOnceODRLinkage; case TSK_ExplicitInstantiationDeclaration: llvm_unreachable("Should not have been asked to emit this"); case TSK_ExplicitInstantiationDefinition: return llvm::GlobalVariable::WeakODRLinkage; } llvm_unreachable("Invalid TemplateSpecializationKind!"); } /// This is a callback from Sema to tell us that it believes that a /// particular v-table is required to be emitted in this translation /// unit. /// /// The reason we don't simply trust this callback is because Sema /// will happily report that something is used even when it's used /// only in code that we don't actually have to emit. /// /// \param isRequired - if true, the v-table is mandatory, e.g. /// because the translation unit defines the key function void CodeGenModule::EmitVTable(CXXRecordDecl *theClass, bool isRequired) { if (!isRequired) return; VTables.GenerateClassData(theClass); } void CodeGenVTables::GenerateClassData(const CXXRecordDecl *RD) { if (CGDebugInfo *DI = CGM.getModuleDebugInfo()) DI->completeClassData(RD); if (RD->getNumVBases()) CGM.getCXXABI().emitVirtualInheritanceTables(RD); CGM.getCXXABI().emitVTableDefinitions(*this, RD); } /// At this point in the translation unit, does it appear that can we /// rely on the vtable being defined elsewhere in the program? /// /// The response is really only definitive when called at the end of /// the translation unit. /// /// The only semantic restriction here is that the object file should /// not contain a v-table definition when that v-table is defined /// strongly elsewhere. Otherwise, we'd just like to avoid emitting /// v-tables when unnecessary. bool CodeGenVTables::isVTableExternal(const CXXRecordDecl *RD) { assert(RD->isDynamicClass() && "Non dynamic classes have no VTable."); // If we have an explicit instantiation declaration (and not a // definition), the v-table is defined elsewhere. TemplateSpecializationKind TSK = RD->getTemplateSpecializationKind(); if (TSK == TSK_ExplicitInstantiationDeclaration) return true; // Otherwise, if the class is an instantiated template, the // v-table must be defined here. if (TSK == TSK_ImplicitInstantiation || TSK == TSK_ExplicitInstantiationDefinition) return false; // Otherwise, if the class doesn't have a key function (possibly // anymore), the v-table must be defined here. const CXXMethodDecl *keyFunction = CGM.getContext().getCurrentKeyFunction(RD); if (!keyFunction) return false; // Otherwise, if we don't have a definition of the key function, the // v-table must be defined somewhere else. return !keyFunction->hasBody(); } /// Given that we're currently at the end of the translation unit, and /// we've emitted a reference to the v-table for this class, should /// we define that v-table? static bool shouldEmitVTableAtEndOfTranslationUnit(CodeGenModule &CGM, const CXXRecordDecl *RD) { return !CGM.getVTables().isVTableExternal(RD); } /// Given that at some point we emitted a reference to one or more /// v-tables, and that we are now at the end of the translation unit, /// decide whether we should emit them. void CodeGenModule::EmitDeferredVTables() { #ifndef NDEBUG // Remember the size of DeferredVTables, because we're going to assume // that this entire operation doesn't modify it. size_t savedSize = DeferredVTables.size(); #endif typedef std::vector::const_iterator const_iterator; for (const_iterator i = DeferredVTables.begin(), e = DeferredVTables.end(); i != e; ++i) { const CXXRecordDecl *RD = *i; if (shouldEmitVTableAtEndOfTranslationUnit(*this, RD)) VTables.GenerateClassData(RD); } assert(savedSize == DeferredVTables.size() && "deferred extra v-tables during v-table emission?"); DeferredVTables.clear(); } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @d32 8 a39 5 CodeGenVTables::CodeGenVTables(CodeGenModule &CGM) : CGM(CGM) { if (CGM.getTarget().getCXXABI().isMicrosoft()) VTContext.reset(new MicrosoftVTableContext(CGM.getContext())); else VTContext.reset(new ItaniumVTableContext(CGM.getContext())); d57 1 a57 2 return GetOrCreateLLVMFunction(Name, Ty, GD, /*ForVTable=*/true, /*DontDefer*/ true); d255 1 a255 1 CGM.getCXXABI().buildThisParam(*this, FunctionArgs); a262 3 if (isa(MD)) CGM.getCXXABI().addImplicitStructorParams(*this, ResultType, FunctionArgs); d425 1 a425 1 if (!UseAvailableExternallyLinkage) { a426 2 CGM.getCXXABI().setThunkLinkage(ThunkFn, ForVTable); } a429 1 CGM.getCXXABI().setThunkLinkage(ThunkFn, ForVTable); d431 2 d463 6 a468 2 const VTableContextBase::ThunkInfoVectorTy *ThunkInfoVector = VTContext->getThunkInfo(GD); d606 1 a606 1 getItaniumVTableContext().createConstructionVTableLayout( d754 1 a754 1 assert(RD->isDynamicClass() && "Non-dynamic classes have no VTable."); @ 1.1.1.3 log @Import Clang 3.5svn r201163. @ text @d32 6 a37 2 CodeGenVTables::CodeGenVTables(CodeGenModule &CGM) : CGM(CGM), VTContext(CGM.getContext().getVTableContext()) {} d61 42 d178 1 a178 1 QualType ResultType = FPT->getReturnType(); d249 1 a249 1 CGM.getCXXABI().HasThisReturn(GD) ? ThisType : FPT->getReturnType(); d320 1 a320 1 CGM.getCXXABI().HasThisReturn(GD) ? ThisType : FPT->getReturnType(); d633 1 a633 1 CGM.setGlobalVisibility(VTable, RD); @ 1.1.1.3.2.1 log @Rebase. @ text @d74 5 a78 5 llvm::BasicBlock *AdjustNull = nullptr; llvm::BasicBlock *AdjustNotNull = nullptr; llvm::BasicBlock *AdjustEnd = nullptr; d162 1 a162 1 llvm::Instruction *ThisStore = nullptr; d220 1 a220 1 MD->getLocation(), SourceLocation()); d324 2 a325 3 llvm::Constant *C = CGM.GetAddrOfThunk(GD, Thunk); llvm::GlobalValue *Entry; d327 1 a327 1 if (llvm::ConstantExpr *CE = dyn_cast(C)) { d329 1 a329 3 Entry = cast(CE->getOperand(0)); } else { Entry = cast(C); d331 1 a331 1 d334 1 a334 1 if (Entry->getType()->getElementType() != d336 2 a337 2 llvm::GlobalValue *OldThunkFn = Entry; d344 1 a344 1 Entry = cast(CGM.GetAddrOfThunk(GD, Thunk)); d446 2 a447 2 llvm::Constant *PureVirtualFn = nullptr, *DeletedVirtualFn = nullptr; d452 1 a452 1 llvm::Constant *Init = nullptr; d557 1 a557 1 std::unique_ptr VTLayout( d617 1 a617 1 const FunctionDecl *def = nullptr; @ 1.1.1.4 log @Import Clang 3.5svn r209886. @ text @d74 5 a78 5 llvm::BasicBlock *AdjustNull = nullptr; llvm::BasicBlock *AdjustNotNull = nullptr; llvm::BasicBlock *AdjustEnd = nullptr; d162 1 a162 1 llvm::Instruction *ThisStore = nullptr; d220 1 a220 1 MD->getLocation(), SourceLocation()); d324 2 a325 3 llvm::Constant *C = CGM.GetAddrOfThunk(GD, Thunk); llvm::GlobalValue *Entry; d327 1 a327 1 if (llvm::ConstantExpr *CE = dyn_cast(C)) { d329 1 a329 3 Entry = cast(CE->getOperand(0)); } else { Entry = cast(C); d331 1 a331 1 d334 1 a334 1 if (Entry->getType()->getElementType() != d336 2 a337 2 llvm::GlobalValue *OldThunkFn = Entry; d344 1 a344 1 Entry = cast(CGM.GetAddrOfThunk(GD, Thunk)); d446 2 a447 2 llvm::Constant *PureVirtualFn = nullptr, *DeletedVirtualFn = nullptr; d452 1 a452 1 llvm::Constant *Init = nullptr; d557 1 a557 1 std::unique_ptr VTLayout( d617 1 a617 1 const FunctionDecl *def = nullptr; @ 1.1.1.5 log @Import clang 3.6svn r215315. @ text @a196 1 CurFuncIsThunk = true; d227 2 a228 1 void CodeGenFunction::EmitCallAndReturnForThunk(llvm::Value *Callee, d232 1 a232 1 const CXXMethodDecl *MD = cast(CurGD.getDecl()); a238 12 if (CurFnInfo->usesInAlloca()) { // We don't handle return adjusting thunks, because they require us to call // the copy constructor. For now, fall through and pretend the return // adjustment was empty so we don't crash. if (Thunk && !Thunk->Return.isEmpty()) { CGM.ErrorUnsupported( MD, "non-trivial argument copy for return-adjusting thunk"); } EmitMustTailThunk(MD, AdjustedThisPtr, Callee); return; } d245 1 a245 1 CGM.getCXXABI().adjustCallArgsForDestructorThunk(*this, CurGD, CallArgs); d248 3 a250 2 for (const ParmVarDecl *PD : MD->params()) EmitDelegateCallArg(CallArgs, PD, PD->getLocStart()); d274 1 a274 1 CGM.getCXXABI().HasThisReturn(CurGD) ? ThisType : FPT->getReturnType(); d282 2 a283 3 llvm::Instruction *CallOrInvoke; RValue RV = EmitCall(*CurFnInfo, Callee, Slot, CallArgs, MD, &CallOrInvoke); a297 56 void CodeGenFunction::EmitMustTailThunk(const CXXMethodDecl *MD, llvm::Value *AdjustedThisPtr, llvm::Value *Callee) { // Emitting a musttail call thunk doesn't use any of the CGCall.cpp machinery // to translate AST arguments into LLVM IR arguments. For thunks, we know // that the caller prototype more or less matches the callee prototype with // the exception of 'this'. SmallVector Args; for (llvm::Argument &A : CurFn->args()) Args.push_back(&A); // Set the adjusted 'this' pointer. const ABIArgInfo &ThisAI = CurFnInfo->arg_begin()->info; if (ThisAI.isDirect()) { const ABIArgInfo &RetAI = CurFnInfo->getReturnInfo(); int ThisArgNo = RetAI.isIndirect() && !RetAI.isSRetAfterThis() ? 1 : 0; llvm::Type *ThisType = Args[ThisArgNo]->getType(); if (ThisType != AdjustedThisPtr->getType()) AdjustedThisPtr = Builder.CreateBitCast(AdjustedThisPtr, ThisType); Args[ThisArgNo] = AdjustedThisPtr; } else { assert(ThisAI.isInAlloca() && "this is passed directly or inalloca"); llvm::Value *ThisAddr = GetAddrOfLocalVar(CXXABIThisDecl); llvm::Type *ThisType = cast(ThisAddr->getType())->getElementType(); if (ThisType != AdjustedThisPtr->getType()) AdjustedThisPtr = Builder.CreateBitCast(AdjustedThisPtr, ThisType); Builder.CreateStore(AdjustedThisPtr, ThisAddr); } // Emit the musttail call manually. Even if the prologue pushed cleanups, we // don't actually want to run them. llvm::CallInst *Call = Builder.CreateCall(Callee, Args); Call->setTailCallKind(llvm::CallInst::TCK_MustTail); // Apply the standard set of call attributes. unsigned CallingConv; CodeGen::AttributeListType AttributeList; CGM.ConstructAttributeList(*CurFnInfo, MD, AttributeList, CallingConv, /*AttrOnCallSite=*/true); llvm::AttributeSet Attrs = llvm::AttributeSet::get(getLLVMContext(), AttributeList); Call->setAttributes(Attrs); Call->setCallingConv(static_cast(CallingConv)); if (Call->getType()->isVoidTy()) Builder.CreateRetVoid(); else Builder.CreateRet(Call); // Finish the function to maintain CodeGenFunction invariants. // FIXME: Don't emit unreachable code. EmitBlock(createBasicBlock()); FinishFunction(); } d309 1 a309 1 EmitCallAndReturnForThunk(Callee, &Thunk); d385 1 a385 2 CGM.getCXXABI().setThunkLinkage(ThunkFn, ForVTable, GD, !Thunk.Return.isEmpty()); d390 1 a390 2 CGM.getCXXABI().setThunkLinkage(ThunkFn, ForVTable, GD, !Thunk.Return.isEmpty()); d432 6 a437 4 llvm::Constant *CodeGenVTables::CreateVTableInitializer( const CXXRecordDecl *RD, const VTableComponent *Components, unsigned NumComponents, const VTableLayout::VTableThunkTy *VTableThunks, unsigned NumVTableThunks, llvm::Constant *RTTI) { d445 3 a594 3 llvm::Constant *RTTI = CGM.GetAddrOfRTTIDescriptor( CGM.getContext().getTagDeclType(Base.getBase())); d596 6 a601 4 llvm::Constant *Init = CreateVTableInitializer( Base.getBase(), VTLayout->vtable_component_begin(), VTLayout->getNumVTableComponents(), VTLayout->vtable_thunk_begin(), VTLayout->getNumVTableThunks(), RTTI); d654 1 a654 14 llvm::GlobalVariable::LinkageTypes DiscardableODRLinkage = llvm::GlobalValue::LinkOnceODRLinkage; llvm::GlobalVariable::LinkageTypes NonDiscardableODRLinkage = llvm::GlobalValue::WeakODRLinkage; if (RD->hasAttr()) { // Cannot discard exported vtables. DiscardableODRLinkage = NonDiscardableODRLinkage; } else if (RD->hasAttr()) { // Imported vtables are available externally. DiscardableODRLinkage = llvm::GlobalVariable::AvailableExternallyLinkage; NonDiscardableODRLinkage = llvm::GlobalVariable::AvailableExternallyLinkage; } d659 1 a659 1 return DiscardableODRLinkage; d665 1 a665 1 return NonDiscardableODRLinkage; @ 1.1.1.5.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @d51 1 a51 1 /*DontDefer=*/true, /*IsThunk=*/true); d162 8 a169 4 llvm::Instruction *ThisStore = std::find_if(EntryBB->begin(), EntryBB->end(), [&](llvm::Instruction &I) { return isa(I) && I.getOperand(0) == ThisPtr; }); d203 2 a204 5 QualType ResultType = CGM.getCXXABI().HasThisReturn(GD) ? ThisType : CGM.getCXXABI().hasMostDerivedReturn(GD) ? CGM.getContext().VoidPtrTy : FPT->getReturnType(); d211 4 a214 1 FunctionArgs.append(MD->param_begin(), MD->param_end()); d221 1 a221 1 MD->getLocation(), MD->getLocation()); d284 2 a285 5 QualType ResultType = CGM.getCXXABI().HasThisReturn(CurGD) ? ThisType : CGM.getCXXABI().hasMostDerivedReturn(CurGD) ? CGM.getContext().VoidPtrTy : FPT->getReturnType(); d683 1 a683 2 const CXXMethodDecl *keyFunction = Context.getCurrentKeyFunction(RD); if (keyFunction && !RD->hasAttr()) { @ 1.1.1.6 log @Import Clang 3.6RC1 r227398. @ text @d51 1 a51 1 /*DontDefer=*/true, /*IsThunk=*/true); d162 8 a169 4 llvm::Instruction *ThisStore = std::find_if(EntryBB->begin(), EntryBB->end(), [&](llvm::Instruction &I) { return isa(I) && I.getOperand(0) == ThisPtr; }); d203 2 a204 5 QualType ResultType = CGM.getCXXABI().HasThisReturn(GD) ? ThisType : CGM.getCXXABI().hasMostDerivedReturn(GD) ? CGM.getContext().VoidPtrTy : FPT->getReturnType(); d211 4 a214 1 FunctionArgs.append(MD->param_begin(), MD->param_end()); d221 1 a221 1 MD->getLocation(), MD->getLocation()); d284 2 a285 5 QualType ResultType = CGM.getCXXABI().HasThisReturn(CurGD) ? ThisType : CGM.getCXXABI().hasMostDerivedReturn(CurGD) ? CGM.getContext().VoidPtrTy : FPT->getReturnType(); d683 1 a683 2 const CXXMethodDecl *keyFunction = Context.getCurrentKeyFunction(RD); if (keyFunction && !RD->hasAttr()) { @ 1.1.1.7 log @Import Clang 3.8.0rc3 r261930. @ text @d47 1 a58 15 static void setThunkProperties(CodeGenModule &CGM, const ThunkInfo &Thunk, llvm::Function *ThunkFn, bool ForVTable, GlobalDecl GD) { CGM.setFunctionLinkage(GD, ThunkFn); CGM.getCXXABI().setThunkLinkage(ThunkFn, ForVTable, GD, !Thunk.Return.isEmpty()); // Set the right visibility. const CXXMethodDecl *MD = cast(GD.getDecl()); setThunkVisibility(CGM, MD, Thunk, ThunkFn); if (CGM.supportsCOMDAT() && ThunkFn->isWeakForLinker()) ThunkFn->setComdat(CGM.getModule().getOrInsertComdat(ThunkFn->getName())); } d91 2 a92 5 auto ClassDecl = ResultType->getPointeeType()->getAsCXXRecordDecl(); auto ClassAlign = CGF.CGM.getClassPointerAlignment(ClassDecl); ReturnValue = CGF.CGM.getCXXABI().performReturnAdjustment(CGF, Address(ReturnValue, ClassAlign), Thunk.Return); d126 2 a127 2 llvm::Function * CodeGenFunction::GenerateVarArgsThunk(llvm::Function *Fn, d160 3 a162 3 Address ThisPtr(&*AI, CGM.getClassPointerAlignment(MD->getParent())); llvm::BasicBlock *EntryBB = &Fn->front(); llvm::BasicBlock::iterator ThisStore = d164 3 a166 5 return isa(I) && I.getOperand(0) == ThisPtr.getPointer(); }); assert(ThisStore != EntryBB->end() && "Store of this should be in entry block?"); d168 1 a168 1 Builder.SetInsertPoint(&*ThisStore); d175 2 a176 2 for (llvm::BasicBlock &BB : *Fn) { llvm::Instruction *T = BB.getTerminator(); d180 1 a180 1 Builder.SetInsertPoint(&BB); a186 2 return Fn; a221 11 CurCodeDecl = MD; CurFuncDecl = MD; } void CodeGenFunction::FinishThunk() { // Clear these to restore the invariants expected by // StartFunction/FinishFunction. CurCodeDecl = nullptr; CurFuncDecl = nullptr; FinishFunction(); d231 3 a233 4 llvm::Value *AdjustedThisPtr = Thunk ? CGM.getCXXABI().performThisAdjustment( *this, LoadCXXThisAddress(), Thunk->This) : LoadCXXThis(); a297 2 else if (llvm::CallInst* Call = dyn_cast(CallOrInvoke)) Call->setTailCallKind(llvm::CallInst::TCK_Tail); d306 1 a306 1 FinishThunk(); d331 3 a333 2 Address ThisAddr = GetAddrOfLocalVar(CXXABIThisDecl); llvm::Type *ThisType = ThisAddr.getElementType(); d347 2 a348 2 CGM.ConstructAttributeList(Callee->getName(), *CurFnInfo, MD, AttributeList, CallingConv, /*AttrOnCallSite=*/true); d365 1 a365 1 void CodeGenFunction::generateThunk(llvm::Function *Fn, d377 7 d437 2 a438 1 setThunkProperties(CGM, Thunk, ThunkFn, ForVTable, GD); d450 5 a454 4 if (UseAvailableExternallyLinkage) return; ThunkFn = CodeGenFunction(CGM).GenerateVarArgsThunk(ThunkFn, FnInfo, GD, Thunk); d457 3 a459 1 CodeGenFunction(CGM).generateThunk(ThunkFn, FnInfo, GD, Thunk); a460 2 setThunkProperties(CGM, Thunk, ThunkFn, ForVTable, GD); d497 2 a498 2 for (const ThunkInfo& Thunk : *ThunkInfoVector) emitThunk(GD, Thunk, /*ForVTable=*/false); a559 18 if (CGM.getLangOpts().CUDA) { // Emit NULL for methods we can't codegen on this // side. Otherwise we'd end up with vtable with unresolved // references. const CXXMethodDecl *MD = cast(GD.getDecl()); // OK on device side: functions w/ __device__ attribute // OK on host side: anything except __device__-only functions. bool CanEmitMethod = CGM.getLangOpts().CUDAIsDevice ? MD->hasAttr() : (MD->hasAttr() || !MD->hasAttr()); if (!CanEmitMethod) { Init = llvm::ConstantExpr::getNullValue(Int8PtrTy); break; } // Method is acceptable, continue processing as usual. } d637 1 a668 2 CGM.EmitVTableBitSetEntries(VTable, *VTLayout.get()); a671 6 static bool shouldEmitAvailableExternallyVTable(const CodeGenModule &CGM, const CXXRecordDecl *RD) { return CGM.getCodeGenOpts().OptimizationLevel > 0 && CGM.getCXXABI().canSpeculativelyEmitVTable(RD); } d693 1 a693 6 assert((def || CodeGenOpts.OptimizationLevel > 0) && "Shouldn't query vtable linkage without key function or " "optimizations"); if (!def && CodeGenOpts.OptimizationLevel > 0) return llvm::GlobalVariable::AvailableExternallyLinkage; d700 1 a700 1 d735 4 a738 9 case TSK_Undeclared: case TSK_ExplicitSpecialization: case TSK_ImplicitInstantiation: return DiscardableODRLinkage; case TSK_ExplicitInstantiationDeclaration: return shouldEmitAvailableExternallyVTable(*this, RD) ? llvm::GlobalVariable::AvailableExternallyLinkage : llvm::GlobalVariable::ExternalLinkage; d740 5 a744 2 case TSK_ExplicitInstantiationDefinition: return NonDiscardableODRLinkage; d750 7 a756 2 /// This is a callback from Sema to tell us that that a particular v-table is /// required to be emitted in this translation unit. d758 5 a762 4 /// This is only called for vtables that _must_ be emitted (mainly due to key /// functions). For weak vtables, CodeGen tracks when they are needed and /// emits them as-needed. void CodeGenModule::EmitVTable(CXXRecordDecl *theClass) { d818 1 a818 6 // If vtable is internal then it has to be done. if (!CGM.getVTables().isVTableExternal(RD)) return true; // If it's external then maybe we will need it as available_externally. return shouldEmitAvailableExternallyVTable(CGM, RD); d831 4 a834 1 for (const CXXRecordDecl *RD : DeferredVTables) d837 1 a842 64 bool CodeGenModule::IsCFIBlacklistedRecord(const CXXRecordDecl *RD) { if (RD->hasAttr() && getContext().getSanitizerBlacklist().isBlacklistedType("attr:uuid")) return true; return getContext().getSanitizerBlacklist().isBlacklistedType( RD->getQualifiedNameAsString()); } void CodeGenModule::EmitVTableBitSetEntries(llvm::GlobalVariable *VTable, const VTableLayout &VTLayout) { if (!LangOpts.Sanitize.has(SanitizerKind::CFIVCall) && !LangOpts.Sanitize.has(SanitizerKind::CFINVCall) && !LangOpts.Sanitize.has(SanitizerKind::CFIDerivedCast) && !LangOpts.Sanitize.has(SanitizerKind::CFIUnrelatedCast)) return; CharUnits PointerWidth = Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0)); typedef std::pair BSEntry; std::vector BitsetEntries; // Create a bit set entry for each address point. for (auto &&AP : VTLayout.getAddressPoints()) { if (IsCFIBlacklistedRecord(AP.first.getBase())) continue; BitsetEntries.push_back(std::make_pair(AP.first.getBase(), AP.second)); } // Sort the bit set entries for determinism. std::sort(BitsetEntries.begin(), BitsetEntries.end(), [this](const BSEntry &E1, const BSEntry &E2) { if (&E1 == &E2) return false; std::string S1; llvm::raw_string_ostream O1(S1); getCXXABI().getMangleContext().mangleTypeName( QualType(E1.first->getTypeForDecl(), 0), O1); O1.flush(); std::string S2; llvm::raw_string_ostream O2(S2); getCXXABI().getMangleContext().mangleTypeName( QualType(E2.first->getTypeForDecl(), 0), O2); O2.flush(); if (S1 < S2) return true; if (S1 != S2) return false; return E1.second < E2.second; }); llvm::NamedMDNode *BitsetsMD = getModule().getOrInsertNamedMetadata("llvm.bitsets"); for (auto BitsetEntry : BitsetEntries) CreateVTableBitSetEntry(BitsetsMD, VTable, PointerWidth * BitsetEntry.second, BitsetEntry.first); } @ 1.1.1.7.2.1 log @Sync with HEAD @ text @d14 1 a15 1 #include "CodeGenFunction.h" a16 1 #include "ConstantBuilder.h" d21 3 d35 1 a35 1 llvm::Constant *CodeGenModule::GetAddrOfThunk(GlobalDecl GD, d99 1 a99 1 d116 1 a116 1 d119 1 a119 1 PHI->addIncoming(llvm::Constant::getNullValue(ReturnValue->getType()), d123 1 a123 1 d159 3 a161 1 llvm::Function *NewFn = llvm::CloneFunction(BaseFn, VMap); a236 1 auto NL = ApplyDebugLocation::CreateEmpty(*this); d238 1 a238 3 MD->getLocation()); // Create a scope with an artificial location for the body of this function. auto AL = ApplyDebugLocation::CreateArtificial(*this); d256 1 a256 1 void CodeGenFunction::EmitCallAndReturnForThunk(llvm::Constant *CalleePtr, d276 1 a276 1 EmitMustTailThunk(MD, AdjustedThisPtr, CalleePtr); d289 2 a290 2 for (const ParmVarDecl *PD : MD->parameters()) EmitDelegateCallArg(CallArgs, PD, SourceLocation()); d295 3 a297 2 const CGFunctionInfo &CallFnInfo = CGM.getTypes().arrangeCXXMethodCall( CallArgs, FPT, RequiredArgs::forPrototypePlus(FPT, 1, MD)); d323 1 a323 1 d326 1 a326 2 CGCallee Callee = CGCallee::forDirect(CalleePtr, MD); RValue RV = EmitCall(*CurFnInfo, Callee, Slot, CallArgs, &CallOrInvoke); d346 1 a346 1 llvm::Value *CalleePtr) { d375 1 a375 1 llvm::CallInst *Call = Builder.CreateCall(CalleePtr, Args); d381 1 a381 2 CGM.ConstructAttributeList(CalleePtr->getName(), *CurFnInfo, MD, AttributeList, a402 2 // Create a scope with an artificial location for the body of this function. auto AL = ApplyDebugLocation::CreateArtificial(*this); d407 1 a407 1 llvm::Constant *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true); d442 1 a442 1 d449 1 a449 1 d509 1 a509 1 const CXXMethodDecl *MD = d526 30 a555 35 void CodeGenVTables::addVTableComponent( ConstantArrayBuilder &builder, const VTableLayout &layout, unsigned idx, llvm::Constant *rtti, unsigned &nextVTableThunkIndex) { auto &component = layout.vtable_components()[idx]; auto addOffsetConstant = [&](CharUnits offset) { builder.add(llvm::ConstantExpr::getIntToPtr( llvm::ConstantInt::get(CGM.PtrDiffTy, offset.getQuantity()), CGM.Int8PtrTy)); }; switch (component.getKind()) { case VTableComponent::CK_VCallOffset: return addOffsetConstant(component.getVCallOffset()); case VTableComponent::CK_VBaseOffset: return addOffsetConstant(component.getVBaseOffset()); case VTableComponent::CK_OffsetToTop: return addOffsetConstant(component.getOffsetToTop()); case VTableComponent::CK_RTTI: return builder.add(llvm::ConstantExpr::getBitCast(rtti, CGM.Int8PtrTy)); case VTableComponent::CK_FunctionPointer: case VTableComponent::CK_CompleteDtorPointer: case VTableComponent::CK_DeletingDtorPointer: { GlobalDecl GD; // Get the right global decl. switch (component.getKind()) { default: llvm_unreachable("Unexpected vtable component kind"); case VTableComponent::CK_FunctionPointer: GD = component.getFunctionDecl(); d557 4 a560 2 case VTableComponent::CK_CompleteDtorPointer: GD = GlobalDecl(component.getDestructorDecl(), Dtor_Complete); d562 2 a563 2 case VTableComponent::CK_DeletingDtorPointer: GD = GlobalDecl(component.getDestructorDecl(), Dtor_Deleting); d565 19 a583 1 } d585 17 a601 15 if (CGM.getLangOpts().CUDA) { // Emit NULL for methods we can't codegen on this // side. Otherwise we'd end up with vtable with unresolved // references. const CXXMethodDecl *MD = cast(GD.getDecl()); // OK on device side: functions w/ __device__ attribute // OK on host side: anything except __device__-only functions. bool CanEmitMethod = CGM.getLangOpts().CUDAIsDevice ? MD->hasAttr() : (MD->hasAttr() || !MD->hasAttr()); if (!CanEmitMethod) return builder.addNullPointer(CGM.Int8PtrTy); // Method is acceptable, continue processing as usual. } d603 37 a639 8 auto getSpecialVirtualFn = [&](StringRef name) { llvm::FunctionType *fnTy = llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false); llvm::Constant *fn = CGM.CreateRuntimeFunction(fnTy, name); if (auto f = dyn_cast(fn)) f->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); return llvm::ConstantExpr::getBitCast(fn, CGM.Int8PtrTy); }; d641 3 a643 29 llvm::Constant *fnPtr; // Pure virtual member functions. if (cast(GD.getDecl())->isPure()) { if (!PureVirtualFn) PureVirtualFn = getSpecialVirtualFn(CGM.getCXXABI().GetPureVirtualCallName()); fnPtr = PureVirtualFn; // Deleted virtual member functions. } else if (cast(GD.getDecl())->isDeleted()) { if (!DeletedVirtualFn) DeletedVirtualFn = getSpecialVirtualFn(CGM.getCXXABI().GetDeletedVirtualCallName()); fnPtr = DeletedVirtualFn; // Thunks. } else if (nextVTableThunkIndex < layout.vtable_thunks().size() && layout.vtable_thunks()[nextVTableThunkIndex].first == idx) { auto &thunkInfo = layout.vtable_thunks()[nextVTableThunkIndex].second; maybeEmitThunkForVTable(GD, thunkInfo); nextVTableThunkIndex++; fnPtr = CGM.GetAddrOfThunk(GD, thunkInfo); // Otherwise we can use the method definition directly. } else { llvm::Type *fnTy = CGM.getTypes().GetFunctionTypeForVTable(GD); fnPtr = CGM.GetAddrOfFunction(GD, fnTy, /*ForVTable=*/true); d646 6 a651 33 fnPtr = llvm::ConstantExpr::getBitCast(fnPtr, CGM.Int8PtrTy); builder.add(fnPtr); return; } case VTableComponent::CK_UnusedFunctionPointer: return builder.addNullPointer(CGM.Int8PtrTy); } llvm_unreachable("Unexpected vtable component kind"); } llvm::Type *CodeGenVTables::getVTableType(const VTableLayout &layout) { SmallVector tys; for (unsigned i = 0, e = layout.getNumVTables(); i != e; ++i) { tys.push_back(llvm::ArrayType::get(CGM.Int8PtrTy, layout.getVTableSize(i))); } return llvm::StructType::get(CGM.getLLVMContext(), tys); } void CodeGenVTables::createVTableInitializer(ConstantStructBuilder &builder, const VTableLayout &layout, llvm::Constant *rtti) { unsigned nextVTableThunkIndex = 0; for (unsigned i = 0, e = layout.getNumVTables(); i != e; ++i) { auto vtableElem = builder.beginArray(CGM.Int8PtrTy); size_t thisIndex = layout.getVTableOffset(i); size_t nextIndex = thisIndex + layout.getVTableSize(i); for (unsigned i = thisIndex; i != nextIndex; ++i) { addVTableComponent(vtableElem, layout, i, rtti, nextVTableThunkIndex); } vtableElem.finishAndAddTo(builder); d653 3 d659 3 a661 3 CodeGenVTables::GenerateConstructionVTable(const CXXRecordDecl *RD, const BaseSubobject &Base, bool BaseIsVirtual, d682 2 a683 1 llvm::Type *VTType = getVTableType(*VTLayout); d694 2 a695 2 llvm::GlobalVariable *VTable = CGM.CreateOrReplaceCXXRuntimeVariable(Name, VTType, Linkage); d699 1 a699 1 VTable->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); d705 7 a711 6 ConstantInitBuilder builder(CGM); auto components = builder.beginStruct(); createVTableInitializer(components, *VTLayout, RTTI); components.finishAndSetAsInitializer(VTable); CGM.EmitVTableTypeMetadata(VTable, *VTLayout.get()); d722 1 a722 1 /// Compute the required linkage of the vtable for the given class. d725 1 a725 1 llvm::GlobalVariable::LinkageTypes d739 1 a739 1 d753 1 a753 1 d765 1 a765 1 a795 4 // Explicit instantiations in MSVC do not provide vtables, so we must emit // our own. if (getTarget().getCXXABI().isMicrosoft()) return DiscardableODRLinkage; d807 1 a807 1 /// This is a callback from Sema to tell us that that a particular vtable is d817 1 a817 1 void d835 1 a835 1 /// not contain a vtable definition when that vtable is defined d837 1 a837 1 /// vtables when unnecessary. a840 5 // We always synthesize vtables if they are needed in the MS ABI. MSVC doesn't // emit them even if there is an explicit template instantiation. if (CGM.getTarget().getCXXABI().isMicrosoft()) return false; d842 1 a842 1 // definition), the vtable is defined elsewhere. d848 1 a848 1 // vtable must be defined here. d854 1 a854 1 // anymore), the vtable must be defined here. d860 1 a860 1 // vtable must be defined somewhere else. d865 2 a866 2 /// we've emitted a reference to the vtable for this class, should /// we define that vtable? d878 1 a878 1 /// vtables, and that we are now at the end of the translation unit, d892 1 a892 1 "deferred extra vtables during vtable emission?"); d896 3 a898 3 bool CodeGenModule::HasHiddenLTOVisibility(const CXXRecordDecl *RD) { LinkageInfo LV = RD->getLinkageAndVisibility(); if (!isExternallyVisible(LV.getLinkage())) d901 2 a902 27 if (RD->hasAttr() || RD->hasAttr()) return false; if (getTriple().isOSBinFormatCOFF()) { if (RD->hasAttr() || RD->hasAttr()) return false; } else { if (LV.getVisibility() != HiddenVisibility) return false; } if (getCodeGenOpts().LTOVisibilityPublicStd) { const DeclContext *DC = RD; while (1) { auto *D = cast(DC); DC = DC->getParent(); if (isa(DC->getRedeclContext())) { if (auto *ND = dyn_cast(D)) if (const IdentifierInfo *II = ND->getIdentifier()) if (II->isStr("std") || II->isStr("stdext")) return false; break; } } } return true; d905 6 a910 3 void CodeGenModule::EmitVTableTypeMetadata(llvm::GlobalVariable *VTable, const VTableLayout &VTLayout) { if (!getCodeGenOpts().PrepareForLTO) d919 6 a924 5 for (auto &&AP : VTLayout.getAddressPoints()) BitsetEntries.push_back( std::make_pair(AP.first.getBase(), VTLayout.getVTableOffset(AP.second.VTableIndex) + AP.second.AddressPointIndex)); d952 2 d955 3 a957 2 AddVTableTypeMetadata(VTable, PointerWidth * BitsetEntry.second, BitsetEntry.first); @ 1.1.1.8 log @Import Clang pre-4.0.0 r291444. @ text @d14 1 a15 1 #include "CodeGenFunction.h" a16 1 #include "ConstantBuilder.h" d21 3 d35 1 a35 1 llvm::Constant *CodeGenModule::GetAddrOfThunk(GlobalDecl GD, d99 1 a99 1 d116 1 a116 1 d119 1 a119 1 PHI->addIncoming(llvm::Constant::getNullValue(ReturnValue->getType()), d123 1 a123 1 d159 3 a161 1 llvm::Function *NewFn = llvm::CloneFunction(BaseFn, VMap); a236 1 auto NL = ApplyDebugLocation::CreateEmpty(*this); d238 1 a238 3 MD->getLocation()); // Create a scope with an artificial location for the body of this function. auto AL = ApplyDebugLocation::CreateArtificial(*this); d256 1 a256 1 void CodeGenFunction::EmitCallAndReturnForThunk(llvm::Constant *CalleePtr, d276 1 a276 1 EmitMustTailThunk(MD, AdjustedThisPtr, CalleePtr); d289 2 a290 2 for (const ParmVarDecl *PD : MD->parameters()) EmitDelegateCallArg(CallArgs, PD, SourceLocation()); d295 3 a297 2 const CGFunctionInfo &CallFnInfo = CGM.getTypes().arrangeCXXMethodCall( CallArgs, FPT, RequiredArgs::forPrototypePlus(FPT, 1, MD)); d323 1 a323 1 d326 1 a326 2 CGCallee Callee = CGCallee::forDirect(CalleePtr, MD); RValue RV = EmitCall(*CurFnInfo, Callee, Slot, CallArgs, &CallOrInvoke); d346 1 a346 1 llvm::Value *CalleePtr) { d375 1 a375 1 llvm::CallInst *Call = Builder.CreateCall(CalleePtr, Args); d381 1 a381 2 CGM.ConstructAttributeList(CalleePtr->getName(), *CurFnInfo, MD, AttributeList, a402 2 // Create a scope with an artificial location for the body of this function. auto AL = ApplyDebugLocation::CreateArtificial(*this); d407 1 a407 1 llvm::Constant *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true); d442 1 a442 1 d449 1 a449 1 d509 1 a509 1 const CXXMethodDecl *MD = d526 30 a555 35 void CodeGenVTables::addVTableComponent( ConstantArrayBuilder &builder, const VTableLayout &layout, unsigned idx, llvm::Constant *rtti, unsigned &nextVTableThunkIndex) { auto &component = layout.vtable_components()[idx]; auto addOffsetConstant = [&](CharUnits offset) { builder.add(llvm::ConstantExpr::getIntToPtr( llvm::ConstantInt::get(CGM.PtrDiffTy, offset.getQuantity()), CGM.Int8PtrTy)); }; switch (component.getKind()) { case VTableComponent::CK_VCallOffset: return addOffsetConstant(component.getVCallOffset()); case VTableComponent::CK_VBaseOffset: return addOffsetConstant(component.getVBaseOffset()); case VTableComponent::CK_OffsetToTop: return addOffsetConstant(component.getOffsetToTop()); case VTableComponent::CK_RTTI: return builder.add(llvm::ConstantExpr::getBitCast(rtti, CGM.Int8PtrTy)); case VTableComponent::CK_FunctionPointer: case VTableComponent::CK_CompleteDtorPointer: case VTableComponent::CK_DeletingDtorPointer: { GlobalDecl GD; // Get the right global decl. switch (component.getKind()) { default: llvm_unreachable("Unexpected vtable component kind"); case VTableComponent::CK_FunctionPointer: GD = component.getFunctionDecl(); d557 4 a560 2 case VTableComponent::CK_CompleteDtorPointer: GD = GlobalDecl(component.getDestructorDecl(), Dtor_Complete); d562 2 a563 2 case VTableComponent::CK_DeletingDtorPointer: GD = GlobalDecl(component.getDestructorDecl(), Dtor_Deleting); d565 19 a583 1 } d585 17 a601 15 if (CGM.getLangOpts().CUDA) { // Emit NULL for methods we can't codegen on this // side. Otherwise we'd end up with vtable with unresolved // references. const CXXMethodDecl *MD = cast(GD.getDecl()); // OK on device side: functions w/ __device__ attribute // OK on host side: anything except __device__-only functions. bool CanEmitMethod = CGM.getLangOpts().CUDAIsDevice ? MD->hasAttr() : (MD->hasAttr() || !MD->hasAttr()); if (!CanEmitMethod) return builder.addNullPointer(CGM.Int8PtrTy); // Method is acceptable, continue processing as usual. } d603 37 a639 8 auto getSpecialVirtualFn = [&](StringRef name) { llvm::FunctionType *fnTy = llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false); llvm::Constant *fn = CGM.CreateRuntimeFunction(fnTy, name); if (auto f = dyn_cast(fn)) f->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); return llvm::ConstantExpr::getBitCast(fn, CGM.Int8PtrTy); }; d641 3 a643 29 llvm::Constant *fnPtr; // Pure virtual member functions. if (cast(GD.getDecl())->isPure()) { if (!PureVirtualFn) PureVirtualFn = getSpecialVirtualFn(CGM.getCXXABI().GetPureVirtualCallName()); fnPtr = PureVirtualFn; // Deleted virtual member functions. } else if (cast(GD.getDecl())->isDeleted()) { if (!DeletedVirtualFn) DeletedVirtualFn = getSpecialVirtualFn(CGM.getCXXABI().GetDeletedVirtualCallName()); fnPtr = DeletedVirtualFn; // Thunks. } else if (nextVTableThunkIndex < layout.vtable_thunks().size() && layout.vtable_thunks()[nextVTableThunkIndex].first == idx) { auto &thunkInfo = layout.vtable_thunks()[nextVTableThunkIndex].second; maybeEmitThunkForVTable(GD, thunkInfo); nextVTableThunkIndex++; fnPtr = CGM.GetAddrOfThunk(GD, thunkInfo); // Otherwise we can use the method definition directly. } else { llvm::Type *fnTy = CGM.getTypes().GetFunctionTypeForVTable(GD); fnPtr = CGM.GetAddrOfFunction(GD, fnTy, /*ForVTable=*/true); d646 6 a651 33 fnPtr = llvm::ConstantExpr::getBitCast(fnPtr, CGM.Int8PtrTy); builder.add(fnPtr); return; } case VTableComponent::CK_UnusedFunctionPointer: return builder.addNullPointer(CGM.Int8PtrTy); } llvm_unreachable("Unexpected vtable component kind"); } llvm::Type *CodeGenVTables::getVTableType(const VTableLayout &layout) { SmallVector tys; for (unsigned i = 0, e = layout.getNumVTables(); i != e; ++i) { tys.push_back(llvm::ArrayType::get(CGM.Int8PtrTy, layout.getVTableSize(i))); } return llvm::StructType::get(CGM.getLLVMContext(), tys); } void CodeGenVTables::createVTableInitializer(ConstantStructBuilder &builder, const VTableLayout &layout, llvm::Constant *rtti) { unsigned nextVTableThunkIndex = 0; for (unsigned i = 0, e = layout.getNumVTables(); i != e; ++i) { auto vtableElem = builder.beginArray(CGM.Int8PtrTy); size_t thisIndex = layout.getVTableOffset(i); size_t nextIndex = thisIndex + layout.getVTableSize(i); for (unsigned i = thisIndex; i != nextIndex; ++i) { addVTableComponent(vtableElem, layout, i, rtti, nextVTableThunkIndex); } vtableElem.finishAndAddTo(builder); d653 3 d659 3 a661 3 CodeGenVTables::GenerateConstructionVTable(const CXXRecordDecl *RD, const BaseSubobject &Base, bool BaseIsVirtual, d682 2 a683 1 llvm::Type *VTType = getVTableType(*VTLayout); d694 2 a695 2 llvm::GlobalVariable *VTable = CGM.CreateOrReplaceCXXRuntimeVariable(Name, VTType, Linkage); d699 1 a699 1 VTable->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); d705 7 a711 6 ConstantInitBuilder builder(CGM); auto components = builder.beginStruct(); createVTableInitializer(components, *VTLayout, RTTI); components.finishAndSetAsInitializer(VTable); CGM.EmitVTableTypeMetadata(VTable, *VTLayout.get()); d722 1 a722 1 /// Compute the required linkage of the vtable for the given class. d725 1 a725 1 llvm::GlobalVariable::LinkageTypes d739 1 a739 1 d753 1 a753 1 d765 1 a765 1 a795 4 // Explicit instantiations in MSVC do not provide vtables, so we must emit // our own. if (getTarget().getCXXABI().isMicrosoft()) return DiscardableODRLinkage; d807 1 a807 1 /// This is a callback from Sema to tell us that that a particular vtable is d817 1 a817 1 void d835 1 a835 1 /// not contain a vtable definition when that vtable is defined d837 1 a837 1 /// vtables when unnecessary. a840 5 // We always synthesize vtables if they are needed in the MS ABI. MSVC doesn't // emit them even if there is an explicit template instantiation. if (CGM.getTarget().getCXXABI().isMicrosoft()) return false; d842 1 a842 1 // definition), the vtable is defined elsewhere. d848 1 a848 1 // vtable must be defined here. d854 1 a854 1 // anymore), the vtable must be defined here. d860 1 a860 1 // vtable must be defined somewhere else. d865 2 a866 2 /// we've emitted a reference to the vtable for this class, should /// we define that vtable? d878 1 a878 1 /// vtables, and that we are now at the end of the translation unit, d892 1 a892 1 "deferred extra vtables during vtable emission?"); d896 3 a898 3 bool CodeGenModule::HasHiddenLTOVisibility(const CXXRecordDecl *RD) { LinkageInfo LV = RD->getLinkageAndVisibility(); if (!isExternallyVisible(LV.getLinkage())) d901 2 a902 27 if (RD->hasAttr() || RD->hasAttr()) return false; if (getTriple().isOSBinFormatCOFF()) { if (RD->hasAttr() || RD->hasAttr()) return false; } else { if (LV.getVisibility() != HiddenVisibility) return false; } if (getCodeGenOpts().LTOVisibilityPublicStd) { const DeclContext *DC = RD; while (1) { auto *D = cast(DC); DC = DC->getParent(); if (isa(DC->getRedeclContext())) { if (auto *ND = dyn_cast(D)) if (const IdentifierInfo *II = ND->getIdentifier()) if (II->isStr("std") || II->isStr("stdext")) return false; break; } } } return true; d905 6 a910 3 void CodeGenModule::EmitVTableTypeMetadata(llvm::GlobalVariable *VTable, const VTableLayout &VTLayout) { if (!getCodeGenOpts().PrepareForLTO) d919 6 a924 5 for (auto &&AP : VTLayout.getAddressPoints()) BitsetEntries.push_back( std::make_pair(AP.first.getBase(), VTLayout.getVTableOffset(AP.second.VTableIndex) + AP.second.AddressPointIndex)); d952 2 d955 3 a957 2 AddVTableTypeMetadata(VTable, PointerWidth * BitsetEntry.second, BitsetEntry.first); @ 1.1.1.9 log @Import clang r309604 from branches/release_50 @ text @d17 1 a17 1 #include "clang/CodeGen/ConstantInitBuilder.h" a286 3 #ifndef NDEBUG unsigned PrefixArgs = CallArgs.size() - 1; #endif d295 1 a295 1 CallArgs, FPT, RequiredArgs::forPrototypePlus(FPT, 1, MD), PrefixArgs); d379 3 a381 2 llvm::AttributeList Attrs; CGM.ConstructAttributeList(CalleePtr->getName(), *CurFnInfo, MD, Attrs, d383 2 d747 3 a749 4 assert((def || CodeGenOpts.OptimizationLevel > 0 || CodeGenOpts.getDebugInfo() != codegenoptions::NoDebugInfo) && "Shouldn't query vtable linkage without key function, " "optimizations, or debug info"); a902 2 else if (shouldOpportunisticallyEmitVTables()) OpportunisticVTables.push_back(RD); d945 1 a945 1 if (!getCodeGenOpts().LTOUnit) @ 1.1.1.9.4.1 log @Sync with HEAD @ text @d17 1 a20 1 #include "clang/CodeGen/ConstantInitBuilder.h" a21 1 #include "llvm/IR/IntrinsicInst.h" d33 15 a47 3 llvm::Constant *CodeGenModule::GetAddrOfThunk(StringRef Name, llvm::Type *FnTy, GlobalDecl GD) { return GetOrCreateLLVMFunction(Name, FnTy, GD, /*ForVTable=*/true, d51 5 d64 2 a65 6 CGM.setGVProperties(ThunkFn, GD); if (!CGM.getCXXABI().exportThunk()) { ThunkFn->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass); ThunkFn->setDSOLocal(true); } a124 27 /// This function clones a function's DISubprogram node and enters it into /// a value map with the intent that the map can be utilized by the cloner /// to short-circuit Metadata node mapping. /// Furthermore, the function resolves any DILocalVariable nodes referenced /// by dbg.value intrinsics so they can be properly mapped during cloning. static void resolveTopLevelMetadata(llvm::Function *Fn, llvm::ValueToValueMapTy &VMap) { // Clone the DISubprogram node and put it into the Value map. auto *DIS = Fn->getSubprogram(); if (!DIS) return; auto *NewDIS = DIS->replaceWithDistinct(DIS->clone()); VMap.MD()[DIS].reset(NewDIS); // Find all llvm.dbg.declare intrinsics and resolve the DILocalVariable nodes // they are referencing. for (auto &BB : Fn->getBasicBlockList()) { for (auto &I : BB) { if (auto *DII = dyn_cast(&I)) { auto *DILocal = DII->getVariable(); if (!DILocal->isResolved()) DILocal->resolve(); } } } } a156 4 // We are cloning a function while some Metadata nodes are still unresolved. // Ensure that the value mapper does not encounter any of them. resolveTopLevelMetadata(BaseFn, VMap); d207 1 a207 2 const CGFunctionInfo &FnInfo, bool IsUnprototyped) { d216 5 a220 9 QualType ResultType; if (IsUnprototyped) ResultType = CGM.getContext().VoidTy; else if (CGM.getCXXABI().HasThisReturn(GD)) ResultType = ThisType; else if (CGM.getCXXABI().hasMostDerivedReturn(GD)) ResultType = CGM.getContext().VoidPtrTy; else ResultType = FPT->getReturnType(); d226 5 a230 8 // Add the rest of the parameters, if we have a prototype to work with. if (!IsUnprototyped) { FunctionArgs.append(MD->param_begin(), MD->param_end()); if (isa(MD)) CGM.getCXXABI().addImplicitStructorParams(*this, ResultType, FunctionArgs); } d256 1 a256 2 const ThunkInfo *Thunk, bool IsUnprototyped) { d267 1 a267 1 if (CurFnInfo->usesInAlloca() || IsUnprototyped) { d272 2 a273 6 if (IsUnprototyped) CGM.ErrorUnsupported( MD, "return-adjusting thunk with incomplete parameter type"); else CGM.ErrorUnsupported( MD, "non-trivial argument copy for return-adjusting thunk"); d400 3 a402 4 const CGFunctionInfo &FnInfo, GlobalDecl GD, const ThunkInfo &Thunk, bool IsUnprototyped) { StartThunk(Fn, GD, FnInfo, IsUnprototyped); d406 3 a408 8 // Get our callee. Use a placeholder type if this method is unprototyped so // that CodeGenModule doesn't try to set attributes. llvm::Type *Ty; if (IsUnprototyped) Ty = llvm::StructType::get(getLLVMContext()); else Ty = CGM.getTypes().GetFunctionType(FnInfo); a410 4 // Fix up the function type for an unprototyped musttail call. if (IsUnprototyped) Callee = llvm::ConstantExpr::getBitCast(Callee, Fn->getType()); d412 1 a412 1 EmitCallAndReturnForThunk(Callee, &Thunk, IsUnprototyped); d415 3 a417 6 static bool shouldEmitVTableThunk(CodeGenModule &CGM, const CXXMethodDecl *MD, bool IsUnprototyped, bool ForVTable) { // Always emit thunks in the MS C++ ABI. We cannot rely on other TUs to // provide thunks for us. if (CGM.getTarget().getCXXABI().isMicrosoft()) return true; d419 3 a421 6 // In the Itanium C++ ABI, vtable thunks are provided by TUs that provide // definitions of the main method. Therefore, emitting thunks with the vtable // is purely an optimization. Emit the thunk if optimizations are enabled and // all of the parameter types are complete. if (ForVTable) return CGM.getCodeGenOpts().OptimizationLevel && !IsUnprototyped; d423 7 a429 3 // Always emit thunks along with the method definition. return true; } d431 9 a439 38 llvm::Constant *CodeGenVTables::maybeEmitThunk(GlobalDecl GD, const ThunkInfo &TI, bool ForVTable) { const CXXMethodDecl *MD = cast(GD.getDecl()); // First, get a declaration. Compute the mangled name. Don't worry about // getting the function prototype right, since we may only need this // declaration to fill in a vtable slot. SmallString<256> Name; MangleContext &MCtx = CGM.getCXXABI().getMangleContext(); llvm::raw_svector_ostream Out(Name); if (const CXXDestructorDecl *DD = dyn_cast(MD)) MCtx.mangleCXXDtorThunk(DD, GD.getDtorType(), TI.This, Out); else MCtx.mangleThunk(MD, TI, Out); llvm::Type *ThunkVTableTy = CGM.getTypes().GetFunctionTypeForVTable(GD); llvm::Constant *Thunk = CGM.GetAddrOfThunk(Name, ThunkVTableTy, GD); // If we don't need to emit a definition, return this declaration as is. bool IsUnprototyped = !CGM.getTypes().isFuncTypeConvertible( MD->getType()->castAs()); if (!shouldEmitVTableThunk(CGM, MD, IsUnprototyped, ForVTable)) return Thunk; // Arrange a function prototype appropriate for a function definition. In some // cases in the MS ABI, we may need to build an unprototyped musttail thunk. const CGFunctionInfo &FnInfo = IsUnprototyped ? CGM.getTypes().arrangeUnprototypedMustTailThunk(MD) : CGM.getTypes().arrangeGlobalDeclaration(GD); llvm::FunctionType *ThunkFnTy = CGM.getTypes().GetFunctionType(FnInfo); // If the type of the underlying GlobalValue is wrong, we'll have to replace // it. It should be a declaration. llvm::Function *ThunkFn = cast(Thunk->stripPointerCasts()); if (ThunkFn->getFunctionType() != ThunkFnTy) { llvm::GlobalValue *OldThunkFn = ThunkFn; assert(OldThunkFn->isDeclaration() && "Shouldn't replace non-declaration"); d443 1 a443 3 ThunkFn = llvm::Function::Create(ThunkFnTy, llvm::Function::ExternalLinkage, Name.str(), &CGM.getModule()); CGM.SetLLVMFunctionAttributes(MD, FnInfo, ThunkFn); d448 1 a448 1 llvm::ConstantExpr::getBitCast(ThunkFn, OldThunkFn->getType()); d456 1 d463 1 a463 1 return ThunkFn; d466 2 a467 2 setThunkProperties(CGM, TI, ThunkFn, ForVTable, GD); return ThunkFn; a469 7 // If this will be unprototyped, add the "thunk" attribute so that LLVM knows // that the return type is meaningless. These thunks can be used to call // functions with differing return types, and the caller is required to cast // the prototype appropriately to extract the correct value. if (IsUnprototyped) ThunkFn->addFnAttr("thunk"); d472 1 a472 1 if (!IsUnprototyped && ThunkFn->isVarArg()) { d479 3 a481 3 return ThunkFn; ThunkFn = CodeGenFunction(CGM).GenerateVarArgsThunk(ThunkFn, FnInfo, GD, TI); d484 1 a484 1 CodeGenFunction(CGM).generateThunk(ThunkFn, FnInfo, GD, TI, IsUnprototyped); d487 1 a487 2 setThunkProperties(CGM, TI, ThunkFn, ForVTable, GD); return ThunkFn; d490 21 a510 1 void CodeGenVTables::EmitThunks(GlobalDecl GD) { d525 1 a525 1 maybeEmitThunk(GD, Thunk, /*ForVTable=*/false); d618 1 d620 1 a620 1 fnPtr = maybeEmitThunk(GD, thunkInfo, /*ForVTable=*/true); d701 1 a701 1 CGM.setGVProperties(VTable, RD); d816 1 a816 1 /// This is a callback from Sema to tell us that a particular vtable is d954 3 a956 2 typedef std::pair AddressPoint; std::vector AddressPoints; d958 9 a966 8 AddressPoints.push_back(std::make_pair( AP.first.getBase(), VTLayout.getVTableOffset(AP.second.VTableIndex) + AP.second.AddressPointIndex)); // Sort the address points for determinism. llvm::sort(AddressPoints.begin(), AddressPoints.end(), [this](const AddressPoint &AP1, const AddressPoint &AP2) { if (&AP1 == &AP2) d972 1 a972 1 QualType(AP1.first->getTypeForDecl(), 0), O1); d978 1 a978 1 QualType(AP2.first->getTypeForDecl(), 0), O2); d986 1 a986 1 return AP1.second < AP2.second; d989 3 a991 19 ArrayRef Comps = VTLayout.vtable_components(); for (auto AP : AddressPoints) { // Create type metadata for the address point. AddVTableTypeMetadata(VTable, PointerWidth * AP.second, AP.first); // The class associated with each address point could also potentially be // used for indirect calls via a member function pointer, so we need to // annotate the address of each function pointer with the appropriate member // function pointer type. for (unsigned I = 0; I != Comps.size(); ++I) { if (Comps[I].getKind() != VTableComponent::CK_FunctionPointer) continue; llvm::Metadata *MD = CreateMetadataIdentifierForVirtualMemPtrType( Context.getMemberPointerType( Comps[I].getFunctionDecl()->getType(), Context.getRecordType(AP.first).getTypePtr())); VTable->addTypeMetadata((PointerWidth * I).getQuantity(), MD); } } @ 1.1.1.9.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.9.2.1 log @Sync with HEAD @ text @d17 1 a20 1 #include "clang/CodeGen/ConstantInitBuilder.h" a21 1 #include "llvm/IR/IntrinsicInst.h" d33 15 a47 3 llvm::Constant *CodeGenModule::GetAddrOfThunk(StringRef Name, llvm::Type *FnTy, GlobalDecl GD) { return GetOrCreateLLVMFunction(Name, FnTy, GD, /*ForVTable=*/true, d51 5 d64 2 a65 6 CGM.setGVProperties(ThunkFn, GD); if (!CGM.getCXXABI().exportThunk()) { ThunkFn->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass); ThunkFn->setDSOLocal(true); } a124 27 /// This function clones a function's DISubprogram node and enters it into /// a value map with the intent that the map can be utilized by the cloner /// to short-circuit Metadata node mapping. /// Furthermore, the function resolves any DILocalVariable nodes referenced /// by dbg.value intrinsics so they can be properly mapped during cloning. static void resolveTopLevelMetadata(llvm::Function *Fn, llvm::ValueToValueMapTy &VMap) { // Clone the DISubprogram node and put it into the Value map. auto *DIS = Fn->getSubprogram(); if (!DIS) return; auto *NewDIS = DIS->replaceWithDistinct(DIS->clone()); VMap.MD()[DIS].reset(NewDIS); // Find all llvm.dbg.declare intrinsics and resolve the DILocalVariable nodes // they are referencing. for (auto &BB : Fn->getBasicBlockList()) { for (auto &I : BB) { if (auto *DII = dyn_cast(&I)) { auto *DILocal = DII->getVariable(); if (!DILocal->isResolved()) DILocal->resolve(); } } } } a156 4 // We are cloning a function while some Metadata nodes are still unresolved. // Ensure that the value mapper does not encounter any of them. resolveTopLevelMetadata(BaseFn, VMap); d207 1 a207 2 const CGFunctionInfo &FnInfo, bool IsUnprototyped) { d216 5 a220 9 QualType ResultType; if (IsUnprototyped) ResultType = CGM.getContext().VoidTy; else if (CGM.getCXXABI().HasThisReturn(GD)) ResultType = ThisType; else if (CGM.getCXXABI().hasMostDerivedReturn(GD)) ResultType = CGM.getContext().VoidPtrTy; else ResultType = FPT->getReturnType(); d226 5 a230 8 // Add the rest of the parameters, if we have a prototype to work with. if (!IsUnprototyped) { FunctionArgs.append(MD->param_begin(), MD->param_end()); if (isa(MD)) CGM.getCXXABI().addImplicitStructorParams(*this, ResultType, FunctionArgs); } d256 1 a256 2 const ThunkInfo *Thunk, bool IsUnprototyped) { d267 1 a267 1 if (CurFnInfo->usesInAlloca() || IsUnprototyped) { d272 2 a273 6 if (IsUnprototyped) CGM.ErrorUnsupported( MD, "return-adjusting thunk with incomplete parameter type"); else CGM.ErrorUnsupported( MD, "non-trivial argument copy for return-adjusting thunk"); d400 3 a402 4 const CGFunctionInfo &FnInfo, GlobalDecl GD, const ThunkInfo &Thunk, bool IsUnprototyped) { StartThunk(Fn, GD, FnInfo, IsUnprototyped); d406 3 a408 8 // Get our callee. Use a placeholder type if this method is unprototyped so // that CodeGenModule doesn't try to set attributes. llvm::Type *Ty; if (IsUnprototyped) Ty = llvm::StructType::get(getLLVMContext()); else Ty = CGM.getTypes().GetFunctionType(FnInfo); a410 4 // Fix up the function type for an unprototyped musttail call. if (IsUnprototyped) Callee = llvm::ConstantExpr::getBitCast(Callee, Fn->getType()); d412 1 a412 1 EmitCallAndReturnForThunk(Callee, &Thunk, IsUnprototyped); d415 3 a417 6 static bool shouldEmitVTableThunk(CodeGenModule &CGM, const CXXMethodDecl *MD, bool IsUnprototyped, bool ForVTable) { // Always emit thunks in the MS C++ ABI. We cannot rely on other TUs to // provide thunks for us. if (CGM.getTarget().getCXXABI().isMicrosoft()) return true; d419 3 a421 6 // In the Itanium C++ ABI, vtable thunks are provided by TUs that provide // definitions of the main method. Therefore, emitting thunks with the vtable // is purely an optimization. Emit the thunk if optimizations are enabled and // all of the parameter types are complete. if (ForVTable) return CGM.getCodeGenOpts().OptimizationLevel && !IsUnprototyped; d423 7 a429 3 // Always emit thunks along with the method definition. return true; } d431 9 a439 38 llvm::Constant *CodeGenVTables::maybeEmitThunk(GlobalDecl GD, const ThunkInfo &TI, bool ForVTable) { const CXXMethodDecl *MD = cast(GD.getDecl()); // First, get a declaration. Compute the mangled name. Don't worry about // getting the function prototype right, since we may only need this // declaration to fill in a vtable slot. SmallString<256> Name; MangleContext &MCtx = CGM.getCXXABI().getMangleContext(); llvm::raw_svector_ostream Out(Name); if (const CXXDestructorDecl *DD = dyn_cast(MD)) MCtx.mangleCXXDtorThunk(DD, GD.getDtorType(), TI.This, Out); else MCtx.mangleThunk(MD, TI, Out); llvm::Type *ThunkVTableTy = CGM.getTypes().GetFunctionTypeForVTable(GD); llvm::Constant *Thunk = CGM.GetAddrOfThunk(Name, ThunkVTableTy, GD); // If we don't need to emit a definition, return this declaration as is. bool IsUnprototyped = !CGM.getTypes().isFuncTypeConvertible( MD->getType()->castAs()); if (!shouldEmitVTableThunk(CGM, MD, IsUnprototyped, ForVTable)) return Thunk; // Arrange a function prototype appropriate for a function definition. In some // cases in the MS ABI, we may need to build an unprototyped musttail thunk. const CGFunctionInfo &FnInfo = IsUnprototyped ? CGM.getTypes().arrangeUnprototypedMustTailThunk(MD) : CGM.getTypes().arrangeGlobalDeclaration(GD); llvm::FunctionType *ThunkFnTy = CGM.getTypes().GetFunctionType(FnInfo); // If the type of the underlying GlobalValue is wrong, we'll have to replace // it. It should be a declaration. llvm::Function *ThunkFn = cast(Thunk->stripPointerCasts()); if (ThunkFn->getFunctionType() != ThunkFnTy) { llvm::GlobalValue *OldThunkFn = ThunkFn; assert(OldThunkFn->isDeclaration() && "Shouldn't replace non-declaration"); d443 1 a443 3 ThunkFn = llvm::Function::Create(ThunkFnTy, llvm::Function::ExternalLinkage, Name.str(), &CGM.getModule()); CGM.SetLLVMFunctionAttributes(MD, FnInfo, ThunkFn); d448 1 a448 1 llvm::ConstantExpr::getBitCast(ThunkFn, OldThunkFn->getType()); d456 1 d463 1 a463 1 return ThunkFn; d466 2 a467 2 setThunkProperties(CGM, TI, ThunkFn, ForVTable, GD); return ThunkFn; a469 7 // If this will be unprototyped, add the "thunk" attribute so that LLVM knows // that the return type is meaningless. These thunks can be used to call // functions with differing return types, and the caller is required to cast // the prototype appropriately to extract the correct value. if (IsUnprototyped) ThunkFn->addFnAttr("thunk"); d472 1 a472 1 if (!IsUnprototyped && ThunkFn->isVarArg()) { d479 3 a481 3 return ThunkFn; ThunkFn = CodeGenFunction(CGM).GenerateVarArgsThunk(ThunkFn, FnInfo, GD, TI); d484 1 a484 1 CodeGenFunction(CGM).generateThunk(ThunkFn, FnInfo, GD, TI, IsUnprototyped); d487 1 a487 2 setThunkProperties(CGM, TI, ThunkFn, ForVTable, GD); return ThunkFn; d490 21 a510 1 void CodeGenVTables::EmitThunks(GlobalDecl GD) { d525 1 a525 1 maybeEmitThunk(GD, Thunk, /*ForVTable=*/false); d618 1 d620 1 a620 1 fnPtr = maybeEmitThunk(GD, thunkInfo, /*ForVTable=*/true); d701 1 a701 1 CGM.setGVProperties(VTable, RD); d816 1 a816 1 /// This is a callback from Sema to tell us that a particular vtable is d954 3 a956 2 typedef std::pair AddressPoint; std::vector AddressPoints; d958 9 a966 8 AddressPoints.push_back(std::make_pair( AP.first.getBase(), VTLayout.getVTableOffset(AP.second.VTableIndex) + AP.second.AddressPointIndex)); // Sort the address points for determinism. llvm::sort(AddressPoints.begin(), AddressPoints.end(), [this](const AddressPoint &AP1, const AddressPoint &AP2) { if (&AP1 == &AP2) d972 1 a972 1 QualType(AP1.first->getTypeForDecl(), 0), O1); d978 1 a978 1 QualType(AP2.first->getTypeForDecl(), 0), O2); d986 1 a986 1 return AP1.second < AP2.second; d989 3 a991 19 ArrayRef Comps = VTLayout.vtable_components(); for (auto AP : AddressPoints) { // Create type metadata for the address point. AddVTableTypeMetadata(VTable, PointerWidth * AP.second, AP.first); // The class associated with each address point could also potentially be // used for indirect calls via a member function pointer, so we need to // annotate the address of each function pointer with the appropriate member // function pointer type. for (unsigned I = 0; I != Comps.size(); ++I) { if (Comps[I].getKind() != VTableComponent::CK_FunctionPointer) continue; llvm::Metadata *MD = CreateMetadataIdentifierForVirtualMemPtrType( Context.getMemberPointerType( Comps[I].getFunctionDecl()->getType(), Context.getRecordType(AP.first).getTypePtr())); VTable->addTypeMetadata((PointerWidth * I).getQuantity(), MD); } } @ 1.1.1.10 log @Import clang r337282 from trunk @ text @d17 1 a20 1 #include "clang/CodeGen/ConstantInitBuilder.h" a21 1 #include "llvm/IR/IntrinsicInst.h" d33 15 a47 3 llvm::Constant *CodeGenModule::GetAddrOfThunk(StringRef Name, llvm::Type *FnTy, GlobalDecl GD) { return GetOrCreateLLVMFunction(Name, FnTy, GD, /*ForVTable=*/true, d51 5 d64 2 a65 6 CGM.setGVProperties(ThunkFn, GD); if (!CGM.getCXXABI().exportThunk()) { ThunkFn->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass); ThunkFn->setDSOLocal(true); } a124 27 /// This function clones a function's DISubprogram node and enters it into /// a value map with the intent that the map can be utilized by the cloner /// to short-circuit Metadata node mapping. /// Furthermore, the function resolves any DILocalVariable nodes referenced /// by dbg.value intrinsics so they can be properly mapped during cloning. static void resolveTopLevelMetadata(llvm::Function *Fn, llvm::ValueToValueMapTy &VMap) { // Clone the DISubprogram node and put it into the Value map. auto *DIS = Fn->getSubprogram(); if (!DIS) return; auto *NewDIS = DIS->replaceWithDistinct(DIS->clone()); VMap.MD()[DIS].reset(NewDIS); // Find all llvm.dbg.declare intrinsics and resolve the DILocalVariable nodes // they are referencing. for (auto &BB : Fn->getBasicBlockList()) { for (auto &I : BB) { if (auto *DII = dyn_cast(&I)) { auto *DILocal = DII->getVariable(); if (!DILocal->isResolved()) DILocal->resolve(); } } } } a156 4 // We are cloning a function while some Metadata nodes are still unresolved. // Ensure that the value mapper does not encounter any of them. resolveTopLevelMetadata(BaseFn, VMap); d207 1 a207 2 const CGFunctionInfo &FnInfo, bool IsUnprototyped) { d216 5 a220 9 QualType ResultType; if (IsUnprototyped) ResultType = CGM.getContext().VoidTy; else if (CGM.getCXXABI().HasThisReturn(GD)) ResultType = ThisType; else if (CGM.getCXXABI().hasMostDerivedReturn(GD)) ResultType = CGM.getContext().VoidPtrTy; else ResultType = FPT->getReturnType(); d226 5 a230 8 // Add the rest of the parameters, if we have a prototype to work with. if (!IsUnprototyped) { FunctionArgs.append(MD->param_begin(), MD->param_end()); if (isa(MD)) CGM.getCXXABI().addImplicitStructorParams(*this, ResultType, FunctionArgs); } d256 1 a256 2 const ThunkInfo *Thunk, bool IsUnprototyped) { d267 1 a267 1 if (CurFnInfo->usesInAlloca() || IsUnprototyped) { d272 2 a273 6 if (IsUnprototyped) CGM.ErrorUnsupported( MD, "return-adjusting thunk with incomplete parameter type"); else CGM.ErrorUnsupported( MD, "non-trivial argument copy for return-adjusting thunk"); d400 3 a402 4 const CGFunctionInfo &FnInfo, GlobalDecl GD, const ThunkInfo &Thunk, bool IsUnprototyped) { StartThunk(Fn, GD, FnInfo, IsUnprototyped); d406 3 a408 8 // Get our callee. Use a placeholder type if this method is unprototyped so // that CodeGenModule doesn't try to set attributes. llvm::Type *Ty; if (IsUnprototyped) Ty = llvm::StructType::get(getLLVMContext()); else Ty = CGM.getTypes().GetFunctionType(FnInfo); a410 4 // Fix up the function type for an unprototyped musttail call. if (IsUnprototyped) Callee = llvm::ConstantExpr::getBitCast(Callee, Fn->getType()); d412 1 a412 1 EmitCallAndReturnForThunk(Callee, &Thunk, IsUnprototyped); d415 3 a417 6 static bool shouldEmitVTableThunk(CodeGenModule &CGM, const CXXMethodDecl *MD, bool IsUnprototyped, bool ForVTable) { // Always emit thunks in the MS C++ ABI. We cannot rely on other TUs to // provide thunks for us. if (CGM.getTarget().getCXXABI().isMicrosoft()) return true; d419 3 a421 6 // In the Itanium C++ ABI, vtable thunks are provided by TUs that provide // definitions of the main method. Therefore, emitting thunks with the vtable // is purely an optimization. Emit the thunk if optimizations are enabled and // all of the parameter types are complete. if (ForVTable) return CGM.getCodeGenOpts().OptimizationLevel && !IsUnprototyped; d423 7 a429 3 // Always emit thunks along with the method definition. return true; } d431 9 a439 38 llvm::Constant *CodeGenVTables::maybeEmitThunk(GlobalDecl GD, const ThunkInfo &TI, bool ForVTable) { const CXXMethodDecl *MD = cast(GD.getDecl()); // First, get a declaration. Compute the mangled name. Don't worry about // getting the function prototype right, since we may only need this // declaration to fill in a vtable slot. SmallString<256> Name; MangleContext &MCtx = CGM.getCXXABI().getMangleContext(); llvm::raw_svector_ostream Out(Name); if (const CXXDestructorDecl *DD = dyn_cast(MD)) MCtx.mangleCXXDtorThunk(DD, GD.getDtorType(), TI.This, Out); else MCtx.mangleThunk(MD, TI, Out); llvm::Type *ThunkVTableTy = CGM.getTypes().GetFunctionTypeForVTable(GD); llvm::Constant *Thunk = CGM.GetAddrOfThunk(Name, ThunkVTableTy, GD); // If we don't need to emit a definition, return this declaration as is. bool IsUnprototyped = !CGM.getTypes().isFuncTypeConvertible( MD->getType()->castAs()); if (!shouldEmitVTableThunk(CGM, MD, IsUnprototyped, ForVTable)) return Thunk; // Arrange a function prototype appropriate for a function definition. In some // cases in the MS ABI, we may need to build an unprototyped musttail thunk. const CGFunctionInfo &FnInfo = IsUnprototyped ? CGM.getTypes().arrangeUnprototypedMustTailThunk(MD) : CGM.getTypes().arrangeGlobalDeclaration(GD); llvm::FunctionType *ThunkFnTy = CGM.getTypes().GetFunctionType(FnInfo); // If the type of the underlying GlobalValue is wrong, we'll have to replace // it. It should be a declaration. llvm::Function *ThunkFn = cast(Thunk->stripPointerCasts()); if (ThunkFn->getFunctionType() != ThunkFnTy) { llvm::GlobalValue *OldThunkFn = ThunkFn; assert(OldThunkFn->isDeclaration() && "Shouldn't replace non-declaration"); d443 1 a443 3 ThunkFn = llvm::Function::Create(ThunkFnTy, llvm::Function::ExternalLinkage, Name.str(), &CGM.getModule()); CGM.SetLLVMFunctionAttributes(MD, FnInfo, ThunkFn); d448 1 a448 1 llvm::ConstantExpr::getBitCast(ThunkFn, OldThunkFn->getType()); d456 1 d463 1 a463 1 return ThunkFn; d466 2 a467 2 setThunkProperties(CGM, TI, ThunkFn, ForVTable, GD); return ThunkFn; a469 7 // If this will be unprototyped, add the "thunk" attribute so that LLVM knows // that the return type is meaningless. These thunks can be used to call // functions with differing return types, and the caller is required to cast // the prototype appropriately to extract the correct value. if (IsUnprototyped) ThunkFn->addFnAttr("thunk"); d472 1 a472 1 if (!IsUnprototyped && ThunkFn->isVarArg()) { d479 3 a481 3 return ThunkFn; ThunkFn = CodeGenFunction(CGM).GenerateVarArgsThunk(ThunkFn, FnInfo, GD, TI); d484 1 a484 1 CodeGenFunction(CGM).generateThunk(ThunkFn, FnInfo, GD, TI, IsUnprototyped); d487 1 a487 2 setThunkProperties(CGM, TI, ThunkFn, ForVTable, GD); return ThunkFn; d490 21 a510 1 void CodeGenVTables::EmitThunks(GlobalDecl GD) { d525 1 a525 1 maybeEmitThunk(GD, Thunk, /*ForVTable=*/false); d618 1 d620 1 a620 1 fnPtr = maybeEmitThunk(GD, thunkInfo, /*ForVTable=*/true); d701 1 a701 1 CGM.setGVProperties(VTable, RD); d816 1 a816 1 /// This is a callback from Sema to tell us that a particular vtable is d954 3 a956 2 typedef std::pair AddressPoint; std::vector AddressPoints; d958 9 a966 8 AddressPoints.push_back(std::make_pair( AP.first.getBase(), VTLayout.getVTableOffset(AP.second.VTableIndex) + AP.second.AddressPointIndex)); // Sort the address points for determinism. llvm::sort(AddressPoints.begin(), AddressPoints.end(), [this](const AddressPoint &AP1, const AddressPoint &AP2) { if (&AP1 == &AP2) d972 1 a972 1 QualType(AP1.first->getTypeForDecl(), 0), O1); d978 1 a978 1 QualType(AP2.first->getTypeForDecl(), 0), O2); d986 1 a986 1 return AP1.second < AP2.second; d989 3 a991 19 ArrayRef Comps = VTLayout.vtable_components(); for (auto AP : AddressPoints) { // Create type metadata for the address point. AddVTableTypeMetadata(VTable, PointerWidth * AP.second, AP.first); // The class associated with each address point could also potentially be // used for indirect calls via a member function pointer, so we need to // annotate the address of each function pointer with the appropriate member // function pointer type. for (unsigned I = 0; I != Comps.size(); ++I) { if (Comps[I].getKind() != VTableComponent::CK_FunctionPointer) continue; llvm::Metadata *MD = CreateMetadataIdentifierForVirtualMemPtrType( Context.getMemberPointerType( Comps[I].getFunctionDecl()->getType(), Context.getRecordType(AP.first).getTypePtr())); VTable->addTypeMetadata((PointerWidth * I).getQuantity(), MD); } } @ 1.1.1.11 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.5.4.1 log @file CGVTables.cpp was added on branch tls-maxphys on 2014-08-19 23:47:27 +0000 @ text @d1 842 @ 1.1.1.5.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 842 //===--- CGVTables.cpp - Emit LLVM Code for C++ vtables -------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This contains code dealing with C++ code generation of virtual tables. // //===----------------------------------------------------------------------===// #include "CodeGenFunction.h" #include "CGCXXABI.h" #include "CodeGenModule.h" #include "clang/AST/CXXInheritance.h" #include "clang/AST/RecordLayout.h" #include "clang/CodeGen/CGFunctionInfo.h" #include "clang/Frontend/CodeGenOptions.h" #include "llvm/ADT/DenseSet.h" #include "llvm/ADT/SetVector.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/Format.h" #include "llvm/Transforms/Utils/Cloning.h" #include #include using namespace clang; using namespace CodeGen; CodeGenVTables::CodeGenVTables(CodeGenModule &CGM) : CGM(CGM), VTContext(CGM.getContext().getVTableContext()) {} llvm::Constant *CodeGenModule::GetAddrOfThunk(GlobalDecl GD, const ThunkInfo &Thunk) { const CXXMethodDecl *MD = cast(GD.getDecl()); // Compute the mangled name. SmallString<256> Name; llvm::raw_svector_ostream Out(Name); if (const CXXDestructorDecl* DD = dyn_cast(MD)) getCXXABI().getMangleContext().mangleCXXDtorThunk(DD, GD.getDtorType(), Thunk.This, Out); else getCXXABI().getMangleContext().mangleThunk(MD, Thunk, Out); Out.flush(); llvm::Type *Ty = getTypes().GetFunctionTypeForVTable(GD); return GetOrCreateLLVMFunction(Name, Ty, GD, /*ForVTable=*/true, /*DontDefer*/ true); } static void setThunkVisibility(CodeGenModule &CGM, const CXXMethodDecl *MD, const ThunkInfo &Thunk, llvm::Function *Fn) { CGM.setGlobalVisibility(Fn, MD); } #ifndef NDEBUG static bool similar(const ABIArgInfo &infoL, CanQualType typeL, const ABIArgInfo &infoR, CanQualType typeR) { return (infoL.getKind() == infoR.getKind() && (typeL == typeR || (isa(typeL) && isa(typeR)) || (isa(typeL) && isa(typeR)))); } #endif static RValue PerformReturnAdjustment(CodeGenFunction &CGF, QualType ResultType, RValue RV, const ThunkInfo &Thunk) { // Emit the return adjustment. bool NullCheckValue = !ResultType->isReferenceType(); llvm::BasicBlock *AdjustNull = nullptr; llvm::BasicBlock *AdjustNotNull = nullptr; llvm::BasicBlock *AdjustEnd = nullptr; llvm::Value *ReturnValue = RV.getScalarVal(); if (NullCheckValue) { AdjustNull = CGF.createBasicBlock("adjust.null"); AdjustNotNull = CGF.createBasicBlock("adjust.notnull"); AdjustEnd = CGF.createBasicBlock("adjust.end"); llvm::Value *IsNull = CGF.Builder.CreateIsNull(ReturnValue); CGF.Builder.CreateCondBr(IsNull, AdjustNull, AdjustNotNull); CGF.EmitBlock(AdjustNotNull); } ReturnValue = CGF.CGM.getCXXABI().performReturnAdjustment(CGF, ReturnValue, Thunk.Return); if (NullCheckValue) { CGF.Builder.CreateBr(AdjustEnd); CGF.EmitBlock(AdjustNull); CGF.Builder.CreateBr(AdjustEnd); CGF.EmitBlock(AdjustEnd); llvm::PHINode *PHI = CGF.Builder.CreatePHI(ReturnValue->getType(), 2); PHI->addIncoming(ReturnValue, AdjustNotNull); PHI->addIncoming(llvm::Constant::getNullValue(ReturnValue->getType()), AdjustNull); ReturnValue = PHI; } return RValue::get(ReturnValue); } // This function does roughly the same thing as GenerateThunk, but in a // very different way, so that va_start and va_end work correctly. // FIXME: This function assumes "this" is the first non-sret LLVM argument of // a function, and that there is an alloca built in the entry block // for all accesses to "this". // FIXME: This function assumes there is only one "ret" statement per function. // FIXME: Cloning isn't correct in the presence of indirect goto! // FIXME: This implementation of thunks bloats codesize by duplicating the // function definition. There are alternatives: // 1. Add some sort of stub support to LLVM for cases where we can // do a this adjustment, then a sibcall. // 2. We could transform the definition to take a va_list instead of an // actual variable argument list, then have the thunks (including a // no-op thunk for the regular definition) call va_start/va_end. // There's a bit of per-call overhead for this solution, but it's // better for codesize if the definition is long. void CodeGenFunction::GenerateVarArgsThunk( llvm::Function *Fn, const CGFunctionInfo &FnInfo, GlobalDecl GD, const ThunkInfo &Thunk) { const CXXMethodDecl *MD = cast(GD.getDecl()); const FunctionProtoType *FPT = MD->getType()->getAs(); QualType ResultType = FPT->getReturnType(); // Get the original function assert(FnInfo.isVariadic()); llvm::Type *Ty = CGM.getTypes().GetFunctionType(FnInfo); llvm::Value *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true); llvm::Function *BaseFn = cast(Callee); // Clone to thunk. llvm::ValueToValueMapTy VMap; llvm::Function *NewFn = llvm::CloneFunction(BaseFn, VMap, /*ModuleLevelChanges=*/false); CGM.getModule().getFunctionList().push_back(NewFn); Fn->replaceAllUsesWith(NewFn); NewFn->takeName(Fn); Fn->eraseFromParent(); Fn = NewFn; // "Initialize" CGF (minimally). CurFn = Fn; // Get the "this" value llvm::Function::arg_iterator AI = Fn->arg_begin(); if (CGM.ReturnTypeUsesSRet(FnInfo)) ++AI; // Find the first store of "this", which will be to the alloca associated // with "this". llvm::Value *ThisPtr = &*AI; llvm::BasicBlock *EntryBB = Fn->begin(); llvm::Instruction *ThisStore = nullptr; for (llvm::BasicBlock::iterator I = EntryBB->begin(), E = EntryBB->end(); I != E; I++) { if (isa(I) && I->getOperand(0) == ThisPtr) { ThisStore = cast(I); break; } } assert(ThisStore && "Store of this should be in entry block?"); // Adjust "this", if necessary. Builder.SetInsertPoint(ThisStore); llvm::Value *AdjustedThisPtr = CGM.getCXXABI().performThisAdjustment(*this, ThisPtr, Thunk.This); ThisStore->setOperand(0, AdjustedThisPtr); if (!Thunk.Return.isEmpty()) { // Fix up the returned value, if necessary. for (llvm::Function::iterator I = Fn->begin(), E = Fn->end(); I != E; I++) { llvm::Instruction *T = I->getTerminator(); if (isa(T)) { RValue RV = RValue::get(T->getOperand(0)); T->eraseFromParent(); Builder.SetInsertPoint(&*I); RV = PerformReturnAdjustment(*this, ResultType, RV, Thunk); Builder.CreateRet(RV.getScalarVal()); break; } } } } void CodeGenFunction::StartThunk(llvm::Function *Fn, GlobalDecl GD, const CGFunctionInfo &FnInfo) { assert(!CurGD.getDecl() && "CurGD was already set!"); CurGD = GD; CurFuncIsThunk = true; // Build FunctionArgs. const CXXMethodDecl *MD = cast(GD.getDecl()); QualType ThisType = MD->getThisType(getContext()); const FunctionProtoType *FPT = MD->getType()->getAs(); QualType ResultType = CGM.getCXXABI().HasThisReturn(GD) ? ThisType : FPT->getReturnType(); FunctionArgList FunctionArgs; // Create the implicit 'this' parameter declaration. CGM.getCXXABI().buildThisParam(*this, FunctionArgs); // Add the rest of the parameters. for (FunctionDecl::param_const_iterator I = MD->param_begin(), E = MD->param_end(); I != E; ++I) FunctionArgs.push_back(*I); if (isa(MD)) CGM.getCXXABI().addImplicitStructorParams(*this, ResultType, FunctionArgs); // Start defining the function. StartFunction(GlobalDecl(), ResultType, Fn, FnInfo, FunctionArgs, MD->getLocation(), SourceLocation()); // Since we didn't pass a GlobalDecl to StartFunction, do this ourselves. CGM.getCXXABI().EmitInstanceFunctionProlog(*this); CXXThisValue = CXXABIThisValue; } void CodeGenFunction::EmitCallAndReturnForThunk(llvm::Value *Callee, const ThunkInfo *Thunk) { assert(isa(CurGD.getDecl()) && "Please use a new CGF for this thunk"); const CXXMethodDecl *MD = cast(CurGD.getDecl()); // Adjust the 'this' pointer if necessary llvm::Value *AdjustedThisPtr = Thunk ? CGM.getCXXABI().performThisAdjustment( *this, LoadCXXThis(), Thunk->This) : LoadCXXThis(); if (CurFnInfo->usesInAlloca()) { // We don't handle return adjusting thunks, because they require us to call // the copy constructor. For now, fall through and pretend the return // adjustment was empty so we don't crash. if (Thunk && !Thunk->Return.isEmpty()) { CGM.ErrorUnsupported( MD, "non-trivial argument copy for return-adjusting thunk"); } EmitMustTailThunk(MD, AdjustedThisPtr, Callee); return; } // Start building CallArgs. CallArgList CallArgs; QualType ThisType = MD->getThisType(getContext()); CallArgs.add(RValue::get(AdjustedThisPtr), ThisType); if (isa(MD)) CGM.getCXXABI().adjustCallArgsForDestructorThunk(*this, CurGD, CallArgs); // Add the rest of the arguments. for (const ParmVarDecl *PD : MD->params()) EmitDelegateCallArg(CallArgs, PD, PD->getLocStart()); const FunctionProtoType *FPT = MD->getType()->getAs(); #ifndef NDEBUG const CGFunctionInfo &CallFnInfo = CGM.getTypes().arrangeCXXMethodCall(CallArgs, FPT, RequiredArgs::forPrototypePlus(FPT, 1)); assert(CallFnInfo.getRegParm() == CurFnInfo->getRegParm() && CallFnInfo.isNoReturn() == CurFnInfo->isNoReturn() && CallFnInfo.getCallingConvention() == CurFnInfo->getCallingConvention()); assert(isa(MD) || // ignore dtor return types similar(CallFnInfo.getReturnInfo(), CallFnInfo.getReturnType(), CurFnInfo->getReturnInfo(), CurFnInfo->getReturnType())); assert(CallFnInfo.arg_size() == CurFnInfo->arg_size()); for (unsigned i = 0, e = CurFnInfo->arg_size(); i != e; ++i) assert(similar(CallFnInfo.arg_begin()[i].info, CallFnInfo.arg_begin()[i].type, CurFnInfo->arg_begin()[i].info, CurFnInfo->arg_begin()[i].type)); #endif // Determine whether we have a return value slot to use. QualType ResultType = CGM.getCXXABI().HasThisReturn(CurGD) ? ThisType : FPT->getReturnType(); ReturnValueSlot Slot; if (!ResultType->isVoidType() && CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect && !hasScalarEvaluationKind(CurFnInfo->getReturnType())) Slot = ReturnValueSlot(ReturnValue, ResultType.isVolatileQualified()); // Now emit our call. llvm::Instruction *CallOrInvoke; RValue RV = EmitCall(*CurFnInfo, Callee, Slot, CallArgs, MD, &CallOrInvoke); // Consider return adjustment if we have ThunkInfo. if (Thunk && !Thunk->Return.isEmpty()) RV = PerformReturnAdjustment(*this, ResultType, RV, *Thunk); // Emit return. if (!ResultType->isVoidType() && Slot.isNull()) CGM.getCXXABI().EmitReturnFromThunk(*this, RV, ResultType); // Disable the final ARC autorelease. AutoreleaseResult = false; FinishFunction(); } void CodeGenFunction::EmitMustTailThunk(const CXXMethodDecl *MD, llvm::Value *AdjustedThisPtr, llvm::Value *Callee) { // Emitting a musttail call thunk doesn't use any of the CGCall.cpp machinery // to translate AST arguments into LLVM IR arguments. For thunks, we know // that the caller prototype more or less matches the callee prototype with // the exception of 'this'. SmallVector Args; for (llvm::Argument &A : CurFn->args()) Args.push_back(&A); // Set the adjusted 'this' pointer. const ABIArgInfo &ThisAI = CurFnInfo->arg_begin()->info; if (ThisAI.isDirect()) { const ABIArgInfo &RetAI = CurFnInfo->getReturnInfo(); int ThisArgNo = RetAI.isIndirect() && !RetAI.isSRetAfterThis() ? 1 : 0; llvm::Type *ThisType = Args[ThisArgNo]->getType(); if (ThisType != AdjustedThisPtr->getType()) AdjustedThisPtr = Builder.CreateBitCast(AdjustedThisPtr, ThisType); Args[ThisArgNo] = AdjustedThisPtr; } else { assert(ThisAI.isInAlloca() && "this is passed directly or inalloca"); llvm::Value *ThisAddr = GetAddrOfLocalVar(CXXABIThisDecl); llvm::Type *ThisType = cast(ThisAddr->getType())->getElementType(); if (ThisType != AdjustedThisPtr->getType()) AdjustedThisPtr = Builder.CreateBitCast(AdjustedThisPtr, ThisType); Builder.CreateStore(AdjustedThisPtr, ThisAddr); } // Emit the musttail call manually. Even if the prologue pushed cleanups, we // don't actually want to run them. llvm::CallInst *Call = Builder.CreateCall(Callee, Args); Call->setTailCallKind(llvm::CallInst::TCK_MustTail); // Apply the standard set of call attributes. unsigned CallingConv; CodeGen::AttributeListType AttributeList; CGM.ConstructAttributeList(*CurFnInfo, MD, AttributeList, CallingConv, /*AttrOnCallSite=*/true); llvm::AttributeSet Attrs = llvm::AttributeSet::get(getLLVMContext(), AttributeList); Call->setAttributes(Attrs); Call->setCallingConv(static_cast(CallingConv)); if (Call->getType()->isVoidTy()) Builder.CreateRetVoid(); else Builder.CreateRet(Call); // Finish the function to maintain CodeGenFunction invariants. // FIXME: Don't emit unreachable code. EmitBlock(createBasicBlock()); FinishFunction(); } void CodeGenFunction::GenerateThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo, GlobalDecl GD, const ThunkInfo &Thunk) { StartThunk(Fn, GD, FnInfo); // Get our callee. llvm::Type *Ty = CGM.getTypes().GetFunctionType(CGM.getTypes().arrangeGlobalDeclaration(GD)); llvm::Value *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true); // Make the call and return the result. EmitCallAndReturnForThunk(Callee, &Thunk); // Set the right linkage. CGM.setFunctionLinkage(GD, Fn); // Set the right visibility. const CXXMethodDecl *MD = cast(GD.getDecl()); setThunkVisibility(CGM, MD, Thunk, Fn); } void CodeGenVTables::emitThunk(GlobalDecl GD, const ThunkInfo &Thunk, bool ForVTable) { const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeGlobalDeclaration(GD); // FIXME: re-use FnInfo in this computation. llvm::Constant *C = CGM.GetAddrOfThunk(GD, Thunk); llvm::GlobalValue *Entry; // Strip off a bitcast if we got one back. if (llvm::ConstantExpr *CE = dyn_cast(C)) { assert(CE->getOpcode() == llvm::Instruction::BitCast); Entry = cast(CE->getOperand(0)); } else { Entry = cast(C); } // There's already a declaration with the same name, check if it has the same // type or if we need to replace it. if (Entry->getType()->getElementType() != CGM.getTypes().GetFunctionTypeForVTable(GD)) { llvm::GlobalValue *OldThunkFn = Entry; // If the types mismatch then we have to rewrite the definition. assert(OldThunkFn->isDeclaration() && "Shouldn't replace non-declaration"); // Remove the name from the old thunk function and get a new thunk. OldThunkFn->setName(StringRef()); Entry = cast(CGM.GetAddrOfThunk(GD, Thunk)); // If needed, replace the old thunk with a bitcast. if (!OldThunkFn->use_empty()) { llvm::Constant *NewPtrForOldDecl = llvm::ConstantExpr::getBitCast(Entry, OldThunkFn->getType()); OldThunkFn->replaceAllUsesWith(NewPtrForOldDecl); } // Remove the old thunk. OldThunkFn->eraseFromParent(); } llvm::Function *ThunkFn = cast(Entry); bool ABIHasKeyFunctions = CGM.getTarget().getCXXABI().hasKeyFunctions(); bool UseAvailableExternallyLinkage = ForVTable && ABIHasKeyFunctions; if (!ThunkFn->isDeclaration()) { if (!ABIHasKeyFunctions || UseAvailableExternallyLinkage) { // There is already a thunk emitted for this function, do nothing. return; } // Change the linkage. CGM.setFunctionLinkage(GD, ThunkFn); return; } CGM.SetLLVMFunctionAttributesForDefinition(GD.getDecl(), ThunkFn); if (ThunkFn->isVarArg()) { // Varargs thunks are special; we can't just generate a call because // we can't copy the varargs. Our implementation is rather // expensive/sucky at the moment, so don't generate the thunk unless // we have to. // FIXME: Do something better here; GenerateVarArgsThunk is extremely ugly. if (!UseAvailableExternallyLinkage) { CodeGenFunction(CGM).GenerateVarArgsThunk(ThunkFn, FnInfo, GD, Thunk); CGM.getCXXABI().setThunkLinkage(ThunkFn, ForVTable, GD, !Thunk.Return.isEmpty()); } } else { // Normal thunk body generation. CodeGenFunction(CGM).GenerateThunk(ThunkFn, FnInfo, GD, Thunk); CGM.getCXXABI().setThunkLinkage(ThunkFn, ForVTable, GD, !Thunk.Return.isEmpty()); } } void CodeGenVTables::maybeEmitThunkForVTable(GlobalDecl GD, const ThunkInfo &Thunk) { // If the ABI has key functions, only the TU with the key function should emit // the thunk. However, we can allow inlining of thunks if we emit them with // available_externally linkage together with vtables when optimizations are // enabled. if (CGM.getTarget().getCXXABI().hasKeyFunctions() && !CGM.getCodeGenOpts().OptimizationLevel) return; // We can't emit thunks for member functions with incomplete types. const CXXMethodDecl *MD = cast(GD.getDecl()); if (!CGM.getTypes().isFuncTypeConvertible( MD->getType()->castAs())) return; emitThunk(GD, Thunk, /*ForVTable=*/true); } void CodeGenVTables::EmitThunks(GlobalDecl GD) { const CXXMethodDecl *MD = cast(GD.getDecl())->getCanonicalDecl(); // We don't need to generate thunks for the base destructor. if (isa(MD) && GD.getDtorType() == Dtor_Base) return; const VTableContextBase::ThunkInfoVectorTy *ThunkInfoVector = VTContext->getThunkInfo(GD); if (!ThunkInfoVector) return; for (unsigned I = 0, E = ThunkInfoVector->size(); I != E; ++I) emitThunk(GD, (*ThunkInfoVector)[I], /*ForVTable=*/false); } llvm::Constant *CodeGenVTables::CreateVTableInitializer( const CXXRecordDecl *RD, const VTableComponent *Components, unsigned NumComponents, const VTableLayout::VTableThunkTy *VTableThunks, unsigned NumVTableThunks, llvm::Constant *RTTI) { SmallVector Inits; llvm::Type *Int8PtrTy = CGM.Int8PtrTy; llvm::Type *PtrDiffTy = CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType()); unsigned NextVTableThunkIndex = 0; llvm::Constant *PureVirtualFn = nullptr, *DeletedVirtualFn = nullptr; for (unsigned I = 0; I != NumComponents; ++I) { VTableComponent Component = Components[I]; llvm::Constant *Init = nullptr; switch (Component.getKind()) { case VTableComponent::CK_VCallOffset: Init = llvm::ConstantInt::get(PtrDiffTy, Component.getVCallOffset().getQuantity()); Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy); break; case VTableComponent::CK_VBaseOffset: Init = llvm::ConstantInt::get(PtrDiffTy, Component.getVBaseOffset().getQuantity()); Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy); break; case VTableComponent::CK_OffsetToTop: Init = llvm::ConstantInt::get(PtrDiffTy, Component.getOffsetToTop().getQuantity()); Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy); break; case VTableComponent::CK_RTTI: Init = llvm::ConstantExpr::getBitCast(RTTI, Int8PtrTy); break; case VTableComponent::CK_FunctionPointer: case VTableComponent::CK_CompleteDtorPointer: case VTableComponent::CK_DeletingDtorPointer: { GlobalDecl GD; // Get the right global decl. switch (Component.getKind()) { default: llvm_unreachable("Unexpected vtable component kind"); case VTableComponent::CK_FunctionPointer: GD = Component.getFunctionDecl(); break; case VTableComponent::CK_CompleteDtorPointer: GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Complete); break; case VTableComponent::CK_DeletingDtorPointer: GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Deleting); break; } if (cast(GD.getDecl())->isPure()) { // We have a pure virtual member function. if (!PureVirtualFn) { llvm::FunctionType *Ty = llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false); StringRef PureCallName = CGM.getCXXABI().GetPureVirtualCallName(); PureVirtualFn = CGM.CreateRuntimeFunction(Ty, PureCallName); PureVirtualFn = llvm::ConstantExpr::getBitCast(PureVirtualFn, CGM.Int8PtrTy); } Init = PureVirtualFn; } else if (cast(GD.getDecl())->isDeleted()) { if (!DeletedVirtualFn) { llvm::FunctionType *Ty = llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false); StringRef DeletedCallName = CGM.getCXXABI().GetDeletedVirtualCallName(); DeletedVirtualFn = CGM.CreateRuntimeFunction(Ty, DeletedCallName); DeletedVirtualFn = llvm::ConstantExpr::getBitCast(DeletedVirtualFn, CGM.Int8PtrTy); } Init = DeletedVirtualFn; } else { // Check if we should use a thunk. if (NextVTableThunkIndex < NumVTableThunks && VTableThunks[NextVTableThunkIndex].first == I) { const ThunkInfo &Thunk = VTableThunks[NextVTableThunkIndex].second; maybeEmitThunkForVTable(GD, Thunk); Init = CGM.GetAddrOfThunk(GD, Thunk); NextVTableThunkIndex++; } else { llvm::Type *Ty = CGM.getTypes().GetFunctionTypeForVTable(GD); Init = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true); } Init = llvm::ConstantExpr::getBitCast(Init, Int8PtrTy); } break; } case VTableComponent::CK_UnusedFunctionPointer: Init = llvm::ConstantExpr::getNullValue(Int8PtrTy); break; }; Inits.push_back(Init); } llvm::ArrayType *ArrayType = llvm::ArrayType::get(Int8PtrTy, NumComponents); return llvm::ConstantArray::get(ArrayType, Inits); } llvm::GlobalVariable * CodeGenVTables::GenerateConstructionVTable(const CXXRecordDecl *RD, const BaseSubobject &Base, bool BaseIsVirtual, llvm::GlobalVariable::LinkageTypes Linkage, VTableAddressPointsMapTy& AddressPoints) { if (CGDebugInfo *DI = CGM.getModuleDebugInfo()) DI->completeClassData(Base.getBase()); std::unique_ptr VTLayout( getItaniumVTableContext().createConstructionVTableLayout( Base.getBase(), Base.getBaseOffset(), BaseIsVirtual, RD)); // Add the address points. AddressPoints = VTLayout->getAddressPoints(); // Get the mangled construction vtable name. SmallString<256> OutName; llvm::raw_svector_ostream Out(OutName); cast(CGM.getCXXABI().getMangleContext()) .mangleCXXCtorVTable(RD, Base.getBaseOffset().getQuantity(), Base.getBase(), Out); Out.flush(); StringRef Name = OutName.str(); llvm::ArrayType *ArrayType = llvm::ArrayType::get(CGM.Int8PtrTy, VTLayout->getNumVTableComponents()); // Construction vtable symbols are not part of the Itanium ABI, so we cannot // guarantee that they actually will be available externally. Instead, when // emitting an available_externally VTT, we provide references to an internal // linkage construction vtable. The ABI only requires complete-object vtables // to be the same for all instances of a type, not construction vtables. if (Linkage == llvm::GlobalVariable::AvailableExternallyLinkage) Linkage = llvm::GlobalVariable::InternalLinkage; // Create the variable that will hold the construction vtable. llvm::GlobalVariable *VTable = CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType, Linkage); CGM.setGlobalVisibility(VTable, RD); // V-tables are always unnamed_addr. VTable->setUnnamedAddr(true); llvm::Constant *RTTI = CGM.GetAddrOfRTTIDescriptor( CGM.getContext().getTagDeclType(Base.getBase())); // Create and set the initializer. llvm::Constant *Init = CreateVTableInitializer( Base.getBase(), VTLayout->vtable_component_begin(), VTLayout->getNumVTableComponents(), VTLayout->vtable_thunk_begin(), VTLayout->getNumVTableThunks(), RTTI); VTable->setInitializer(Init); return VTable; } /// Compute the required linkage of the v-table for the given class. /// /// Note that we only call this at the end of the translation unit. llvm::GlobalVariable::LinkageTypes CodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) { if (!RD->isExternallyVisible()) return llvm::GlobalVariable::InternalLinkage; // We're at the end of the translation unit, so the current key // function is fully correct. if (const CXXMethodDecl *keyFunction = Context.getCurrentKeyFunction(RD)) { // If this class has a key function, use that to determine the // linkage of the vtable. const FunctionDecl *def = nullptr; if (keyFunction->hasBody(def)) keyFunction = cast(def); switch (keyFunction->getTemplateSpecializationKind()) { case TSK_Undeclared: case TSK_ExplicitSpecialization: assert(def && "Should not have been asked to emit this"); if (keyFunction->isInlined()) return !Context.getLangOpts().AppleKext ? llvm::GlobalVariable::LinkOnceODRLinkage : llvm::Function::InternalLinkage; return llvm::GlobalVariable::ExternalLinkage; case TSK_ImplicitInstantiation: return !Context.getLangOpts().AppleKext ? llvm::GlobalVariable::LinkOnceODRLinkage : llvm::Function::InternalLinkage; case TSK_ExplicitInstantiationDefinition: return !Context.getLangOpts().AppleKext ? llvm::GlobalVariable::WeakODRLinkage : llvm::Function::InternalLinkage; case TSK_ExplicitInstantiationDeclaration: llvm_unreachable("Should not have been asked to emit this"); } } // -fapple-kext mode does not support weak linkage, so we must use // internal linkage. if (Context.getLangOpts().AppleKext) return llvm::Function::InternalLinkage; llvm::GlobalVariable::LinkageTypes DiscardableODRLinkage = llvm::GlobalValue::LinkOnceODRLinkage; llvm::GlobalVariable::LinkageTypes NonDiscardableODRLinkage = llvm::GlobalValue::WeakODRLinkage; if (RD->hasAttr()) { // Cannot discard exported vtables. DiscardableODRLinkage = NonDiscardableODRLinkage; } else if (RD->hasAttr()) { // Imported vtables are available externally. DiscardableODRLinkage = llvm::GlobalVariable::AvailableExternallyLinkage; NonDiscardableODRLinkage = llvm::GlobalVariable::AvailableExternallyLinkage; } switch (RD->getTemplateSpecializationKind()) { case TSK_Undeclared: case TSK_ExplicitSpecialization: case TSK_ImplicitInstantiation: return DiscardableODRLinkage; case TSK_ExplicitInstantiationDeclaration: llvm_unreachable("Should not have been asked to emit this"); case TSK_ExplicitInstantiationDefinition: return NonDiscardableODRLinkage; } llvm_unreachable("Invalid TemplateSpecializationKind!"); } /// This is a callback from Sema to tell us that it believes that a /// particular v-table is required to be emitted in this translation /// unit. /// /// The reason we don't simply trust this callback is because Sema /// will happily report that something is used even when it's used /// only in code that we don't actually have to emit. /// /// \param isRequired - if true, the v-table is mandatory, e.g. /// because the translation unit defines the key function void CodeGenModule::EmitVTable(CXXRecordDecl *theClass, bool isRequired) { if (!isRequired) return; VTables.GenerateClassData(theClass); } void CodeGenVTables::GenerateClassData(const CXXRecordDecl *RD) { if (CGDebugInfo *DI = CGM.getModuleDebugInfo()) DI->completeClassData(RD); if (RD->getNumVBases()) CGM.getCXXABI().emitVirtualInheritanceTables(RD); CGM.getCXXABI().emitVTableDefinitions(*this, RD); } /// At this point in the translation unit, does it appear that can we /// rely on the vtable being defined elsewhere in the program? /// /// The response is really only definitive when called at the end of /// the translation unit. /// /// The only semantic restriction here is that the object file should /// not contain a v-table definition when that v-table is defined /// strongly elsewhere. Otherwise, we'd just like to avoid emitting /// v-tables when unnecessary. bool CodeGenVTables::isVTableExternal(const CXXRecordDecl *RD) { assert(RD->isDynamicClass() && "Non-dynamic classes have no VTable."); // If we have an explicit instantiation declaration (and not a // definition), the v-table is defined elsewhere. TemplateSpecializationKind TSK = RD->getTemplateSpecializationKind(); if (TSK == TSK_ExplicitInstantiationDeclaration) return true; // Otherwise, if the class is an instantiated template, the // v-table must be defined here. if (TSK == TSK_ImplicitInstantiation || TSK == TSK_ExplicitInstantiationDefinition) return false; // Otherwise, if the class doesn't have a key function (possibly // anymore), the v-table must be defined here. const CXXMethodDecl *keyFunction = CGM.getContext().getCurrentKeyFunction(RD); if (!keyFunction) return false; // Otherwise, if we don't have a definition of the key function, the // v-table must be defined somewhere else. return !keyFunction->hasBody(); } /// Given that we're currently at the end of the translation unit, and /// we've emitted a reference to the v-table for this class, should /// we define that v-table? static bool shouldEmitVTableAtEndOfTranslationUnit(CodeGenModule &CGM, const CXXRecordDecl *RD) { return !CGM.getVTables().isVTableExternal(RD); } /// Given that at some point we emitted a reference to one or more /// v-tables, and that we are now at the end of the translation unit, /// decide whether we should emit them. void CodeGenModule::EmitDeferredVTables() { #ifndef NDEBUG // Remember the size of DeferredVTables, because we're going to assume // that this entire operation doesn't modify it. size_t savedSize = DeferredVTables.size(); #endif typedef std::vector::const_iterator const_iterator; for (const_iterator i = DeferredVTables.begin(), e = DeferredVTables.end(); i != e; ++i) { const CXXRecordDecl *RD = *i; if (shouldEmitVTableAtEndOfTranslationUnit(*this, RD)) VTables.GenerateClassData(RD); } assert(savedSize == DeferredVTables.size() && "deferred extra v-tables during v-table emission?"); DeferredVTables.clear(); } @ 1.1.1.3.4.1 log @file CGVTables.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:27 +0000 @ text @d1 760 @ 1.1.1.3.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 760 //===--- CGVTables.cpp - Emit LLVM Code for C++ vtables -------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This contains code dealing with C++ code generation of virtual tables. // //===----------------------------------------------------------------------===// #include "CodeGenFunction.h" #include "CGCXXABI.h" #include "CodeGenModule.h" #include "clang/AST/CXXInheritance.h" #include "clang/AST/RecordLayout.h" #include "clang/CodeGen/CGFunctionInfo.h" #include "clang/Frontend/CodeGenOptions.h" #include "llvm/ADT/DenseSet.h" #include "llvm/ADT/SetVector.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/Format.h" #include "llvm/Transforms/Utils/Cloning.h" #include #include using namespace clang; using namespace CodeGen; CodeGenVTables::CodeGenVTables(CodeGenModule &CGM) : CGM(CGM), VTContext(CGM.getContext().getVTableContext()) {} llvm::Constant *CodeGenModule::GetAddrOfThunk(GlobalDecl GD, const ThunkInfo &Thunk) { const CXXMethodDecl *MD = cast(GD.getDecl()); // Compute the mangled name. SmallString<256> Name; llvm::raw_svector_ostream Out(Name); if (const CXXDestructorDecl* DD = dyn_cast(MD)) getCXXABI().getMangleContext().mangleCXXDtorThunk(DD, GD.getDtorType(), Thunk.This, Out); else getCXXABI().getMangleContext().mangleThunk(MD, Thunk, Out); Out.flush(); llvm::Type *Ty = getTypes().GetFunctionTypeForVTable(GD); return GetOrCreateLLVMFunction(Name, Ty, GD, /*ForVTable=*/true, /*DontDefer*/ true); } static void setThunkVisibility(CodeGenModule &CGM, const CXXMethodDecl *MD, const ThunkInfo &Thunk, llvm::Function *Fn) { CGM.setGlobalVisibility(Fn, MD); } #ifndef NDEBUG static bool similar(const ABIArgInfo &infoL, CanQualType typeL, const ABIArgInfo &infoR, CanQualType typeR) { return (infoL.getKind() == infoR.getKind() && (typeL == typeR || (isa(typeL) && isa(typeR)) || (isa(typeL) && isa(typeR)))); } #endif static RValue PerformReturnAdjustment(CodeGenFunction &CGF, QualType ResultType, RValue RV, const ThunkInfo &Thunk) { // Emit the return adjustment. bool NullCheckValue = !ResultType->isReferenceType(); llvm::BasicBlock *AdjustNull = 0; llvm::BasicBlock *AdjustNotNull = 0; llvm::BasicBlock *AdjustEnd = 0; llvm::Value *ReturnValue = RV.getScalarVal(); if (NullCheckValue) { AdjustNull = CGF.createBasicBlock("adjust.null"); AdjustNotNull = CGF.createBasicBlock("adjust.notnull"); AdjustEnd = CGF.createBasicBlock("adjust.end"); llvm::Value *IsNull = CGF.Builder.CreateIsNull(ReturnValue); CGF.Builder.CreateCondBr(IsNull, AdjustNull, AdjustNotNull); CGF.EmitBlock(AdjustNotNull); } ReturnValue = CGF.CGM.getCXXABI().performReturnAdjustment(CGF, ReturnValue, Thunk.Return); if (NullCheckValue) { CGF.Builder.CreateBr(AdjustEnd); CGF.EmitBlock(AdjustNull); CGF.Builder.CreateBr(AdjustEnd); CGF.EmitBlock(AdjustEnd); llvm::PHINode *PHI = CGF.Builder.CreatePHI(ReturnValue->getType(), 2); PHI->addIncoming(ReturnValue, AdjustNotNull); PHI->addIncoming(llvm::Constant::getNullValue(ReturnValue->getType()), AdjustNull); ReturnValue = PHI; } return RValue::get(ReturnValue); } // This function does roughly the same thing as GenerateThunk, but in a // very different way, so that va_start and va_end work correctly. // FIXME: This function assumes "this" is the first non-sret LLVM argument of // a function, and that there is an alloca built in the entry block // for all accesses to "this". // FIXME: This function assumes there is only one "ret" statement per function. // FIXME: Cloning isn't correct in the presence of indirect goto! // FIXME: This implementation of thunks bloats codesize by duplicating the // function definition. There are alternatives: // 1. Add some sort of stub support to LLVM for cases where we can // do a this adjustment, then a sibcall. // 2. We could transform the definition to take a va_list instead of an // actual variable argument list, then have the thunks (including a // no-op thunk for the regular definition) call va_start/va_end. // There's a bit of per-call overhead for this solution, but it's // better for codesize if the definition is long. void CodeGenFunction::GenerateVarArgsThunk( llvm::Function *Fn, const CGFunctionInfo &FnInfo, GlobalDecl GD, const ThunkInfo &Thunk) { const CXXMethodDecl *MD = cast(GD.getDecl()); const FunctionProtoType *FPT = MD->getType()->getAs(); QualType ResultType = FPT->getReturnType(); // Get the original function assert(FnInfo.isVariadic()); llvm::Type *Ty = CGM.getTypes().GetFunctionType(FnInfo); llvm::Value *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true); llvm::Function *BaseFn = cast(Callee); // Clone to thunk. llvm::ValueToValueMapTy VMap; llvm::Function *NewFn = llvm::CloneFunction(BaseFn, VMap, /*ModuleLevelChanges=*/false); CGM.getModule().getFunctionList().push_back(NewFn); Fn->replaceAllUsesWith(NewFn); NewFn->takeName(Fn); Fn->eraseFromParent(); Fn = NewFn; // "Initialize" CGF (minimally). CurFn = Fn; // Get the "this" value llvm::Function::arg_iterator AI = Fn->arg_begin(); if (CGM.ReturnTypeUsesSRet(FnInfo)) ++AI; // Find the first store of "this", which will be to the alloca associated // with "this". llvm::Value *ThisPtr = &*AI; llvm::BasicBlock *EntryBB = Fn->begin(); llvm::Instruction *ThisStore = 0; for (llvm::BasicBlock::iterator I = EntryBB->begin(), E = EntryBB->end(); I != E; I++) { if (isa(I) && I->getOperand(0) == ThisPtr) { ThisStore = cast(I); break; } } assert(ThisStore && "Store of this should be in entry block?"); // Adjust "this", if necessary. Builder.SetInsertPoint(ThisStore); llvm::Value *AdjustedThisPtr = CGM.getCXXABI().performThisAdjustment(*this, ThisPtr, Thunk.This); ThisStore->setOperand(0, AdjustedThisPtr); if (!Thunk.Return.isEmpty()) { // Fix up the returned value, if necessary. for (llvm::Function::iterator I = Fn->begin(), E = Fn->end(); I != E; I++) { llvm::Instruction *T = I->getTerminator(); if (isa(T)) { RValue RV = RValue::get(T->getOperand(0)); T->eraseFromParent(); Builder.SetInsertPoint(&*I); RV = PerformReturnAdjustment(*this, ResultType, RV, Thunk); Builder.CreateRet(RV.getScalarVal()); break; } } } } void CodeGenFunction::StartThunk(llvm::Function *Fn, GlobalDecl GD, const CGFunctionInfo &FnInfo) { assert(!CurGD.getDecl() && "CurGD was already set!"); CurGD = GD; // Build FunctionArgs. const CXXMethodDecl *MD = cast(GD.getDecl()); QualType ThisType = MD->getThisType(getContext()); const FunctionProtoType *FPT = MD->getType()->getAs(); QualType ResultType = CGM.getCXXABI().HasThisReturn(GD) ? ThisType : FPT->getReturnType(); FunctionArgList FunctionArgs; // Create the implicit 'this' parameter declaration. CGM.getCXXABI().buildThisParam(*this, FunctionArgs); // Add the rest of the parameters. for (FunctionDecl::param_const_iterator I = MD->param_begin(), E = MD->param_end(); I != E; ++I) FunctionArgs.push_back(*I); if (isa(MD)) CGM.getCXXABI().addImplicitStructorParams(*this, ResultType, FunctionArgs); // Start defining the function. StartFunction(GlobalDecl(), ResultType, Fn, FnInfo, FunctionArgs, SourceLocation()); // Since we didn't pass a GlobalDecl to StartFunction, do this ourselves. CGM.getCXXABI().EmitInstanceFunctionProlog(*this); CXXThisValue = CXXABIThisValue; } void CodeGenFunction::EmitCallAndReturnForThunk(GlobalDecl GD, llvm::Value *Callee, const ThunkInfo *Thunk) { assert(isa(CurGD.getDecl()) && "Please use a new CGF for this thunk"); const CXXMethodDecl *MD = cast(GD.getDecl()); // Adjust the 'this' pointer if necessary llvm::Value *AdjustedThisPtr = Thunk ? CGM.getCXXABI().performThisAdjustment( *this, LoadCXXThis(), Thunk->This) : LoadCXXThis(); // Start building CallArgs. CallArgList CallArgs; QualType ThisType = MD->getThisType(getContext()); CallArgs.add(RValue::get(AdjustedThisPtr), ThisType); if (isa(MD)) CGM.getCXXABI().adjustCallArgsForDestructorThunk(*this, GD, CallArgs); // Add the rest of the arguments. for (FunctionDecl::param_const_iterator I = MD->param_begin(), E = MD->param_end(); I != E; ++I) EmitDelegateCallArg(CallArgs, *I, (*I)->getLocStart()); const FunctionProtoType *FPT = MD->getType()->getAs(); #ifndef NDEBUG const CGFunctionInfo &CallFnInfo = CGM.getTypes().arrangeCXXMethodCall(CallArgs, FPT, RequiredArgs::forPrototypePlus(FPT, 1)); assert(CallFnInfo.getRegParm() == CurFnInfo->getRegParm() && CallFnInfo.isNoReturn() == CurFnInfo->isNoReturn() && CallFnInfo.getCallingConvention() == CurFnInfo->getCallingConvention()); assert(isa(MD) || // ignore dtor return types similar(CallFnInfo.getReturnInfo(), CallFnInfo.getReturnType(), CurFnInfo->getReturnInfo(), CurFnInfo->getReturnType())); assert(CallFnInfo.arg_size() == CurFnInfo->arg_size()); for (unsigned i = 0, e = CurFnInfo->arg_size(); i != e; ++i) assert(similar(CallFnInfo.arg_begin()[i].info, CallFnInfo.arg_begin()[i].type, CurFnInfo->arg_begin()[i].info, CurFnInfo->arg_begin()[i].type)); #endif // Determine whether we have a return value slot to use. QualType ResultType = CGM.getCXXABI().HasThisReturn(GD) ? ThisType : FPT->getReturnType(); ReturnValueSlot Slot; if (!ResultType->isVoidType() && CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect && !hasScalarEvaluationKind(CurFnInfo->getReturnType())) Slot = ReturnValueSlot(ReturnValue, ResultType.isVolatileQualified()); // Now emit our call. RValue RV = EmitCall(*CurFnInfo, Callee, Slot, CallArgs, MD); // Consider return adjustment if we have ThunkInfo. if (Thunk && !Thunk->Return.isEmpty()) RV = PerformReturnAdjustment(*this, ResultType, RV, *Thunk); // Emit return. if (!ResultType->isVoidType() && Slot.isNull()) CGM.getCXXABI().EmitReturnFromThunk(*this, RV, ResultType); // Disable the final ARC autorelease. AutoreleaseResult = false; FinishFunction(); } void CodeGenFunction::GenerateThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo, GlobalDecl GD, const ThunkInfo &Thunk) { StartThunk(Fn, GD, FnInfo); // Get our callee. llvm::Type *Ty = CGM.getTypes().GetFunctionType(CGM.getTypes().arrangeGlobalDeclaration(GD)); llvm::Value *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true); // Make the call and return the result. EmitCallAndReturnForThunk(GD, Callee, &Thunk); // Set the right linkage. CGM.setFunctionLinkage(GD, Fn); // Set the right visibility. const CXXMethodDecl *MD = cast(GD.getDecl()); setThunkVisibility(CGM, MD, Thunk, Fn); } void CodeGenVTables::emitThunk(GlobalDecl GD, const ThunkInfo &Thunk, bool ForVTable) { const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeGlobalDeclaration(GD); // FIXME: re-use FnInfo in this computation. llvm::Constant *Entry = CGM.GetAddrOfThunk(GD, Thunk); // Strip off a bitcast if we got one back. if (llvm::ConstantExpr *CE = dyn_cast(Entry)) { assert(CE->getOpcode() == llvm::Instruction::BitCast); Entry = CE->getOperand(0); } // There's already a declaration with the same name, check if it has the same // type or if we need to replace it. if (cast(Entry)->getType()->getElementType() != CGM.getTypes().GetFunctionTypeForVTable(GD)) { llvm::GlobalValue *OldThunkFn = cast(Entry); // If the types mismatch then we have to rewrite the definition. assert(OldThunkFn->isDeclaration() && "Shouldn't replace non-declaration"); // Remove the name from the old thunk function and get a new thunk. OldThunkFn->setName(StringRef()); Entry = CGM.GetAddrOfThunk(GD, Thunk); // If needed, replace the old thunk with a bitcast. if (!OldThunkFn->use_empty()) { llvm::Constant *NewPtrForOldDecl = llvm::ConstantExpr::getBitCast(Entry, OldThunkFn->getType()); OldThunkFn->replaceAllUsesWith(NewPtrForOldDecl); } // Remove the old thunk. OldThunkFn->eraseFromParent(); } llvm::Function *ThunkFn = cast(Entry); bool ABIHasKeyFunctions = CGM.getTarget().getCXXABI().hasKeyFunctions(); bool UseAvailableExternallyLinkage = ForVTable && ABIHasKeyFunctions; if (!ThunkFn->isDeclaration()) { if (!ABIHasKeyFunctions || UseAvailableExternallyLinkage) { // There is already a thunk emitted for this function, do nothing. return; } // Change the linkage. CGM.setFunctionLinkage(GD, ThunkFn); return; } CGM.SetLLVMFunctionAttributesForDefinition(GD.getDecl(), ThunkFn); if (ThunkFn->isVarArg()) { // Varargs thunks are special; we can't just generate a call because // we can't copy the varargs. Our implementation is rather // expensive/sucky at the moment, so don't generate the thunk unless // we have to. // FIXME: Do something better here; GenerateVarArgsThunk is extremely ugly. if (!UseAvailableExternallyLinkage) { CodeGenFunction(CGM).GenerateVarArgsThunk(ThunkFn, FnInfo, GD, Thunk); CGM.getCXXABI().setThunkLinkage(ThunkFn, ForVTable); } } else { // Normal thunk body generation. CodeGenFunction(CGM).GenerateThunk(ThunkFn, FnInfo, GD, Thunk); CGM.getCXXABI().setThunkLinkage(ThunkFn, ForVTable); } } void CodeGenVTables::maybeEmitThunkForVTable(GlobalDecl GD, const ThunkInfo &Thunk) { // If the ABI has key functions, only the TU with the key function should emit // the thunk. However, we can allow inlining of thunks if we emit them with // available_externally linkage together with vtables when optimizations are // enabled. if (CGM.getTarget().getCXXABI().hasKeyFunctions() && !CGM.getCodeGenOpts().OptimizationLevel) return; // We can't emit thunks for member functions with incomplete types. const CXXMethodDecl *MD = cast(GD.getDecl()); if (!CGM.getTypes().isFuncTypeConvertible( MD->getType()->castAs())) return; emitThunk(GD, Thunk, /*ForVTable=*/true); } void CodeGenVTables::EmitThunks(GlobalDecl GD) { const CXXMethodDecl *MD = cast(GD.getDecl())->getCanonicalDecl(); // We don't need to generate thunks for the base destructor. if (isa(MD) && GD.getDtorType() == Dtor_Base) return; const VTableContextBase::ThunkInfoVectorTy *ThunkInfoVector = VTContext->getThunkInfo(GD); if (!ThunkInfoVector) return; for (unsigned I = 0, E = ThunkInfoVector->size(); I != E; ++I) emitThunk(GD, (*ThunkInfoVector)[I], /*ForVTable=*/false); } llvm::Constant * CodeGenVTables::CreateVTableInitializer(const CXXRecordDecl *RD, const VTableComponent *Components, unsigned NumComponents, const VTableLayout::VTableThunkTy *VTableThunks, unsigned NumVTableThunks) { SmallVector Inits; llvm::Type *Int8PtrTy = CGM.Int8PtrTy; llvm::Type *PtrDiffTy = CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType()); QualType ClassType = CGM.getContext().getTagDeclType(RD); llvm::Constant *RTTI = CGM.GetAddrOfRTTIDescriptor(ClassType); unsigned NextVTableThunkIndex = 0; llvm::Constant *PureVirtualFn = 0, *DeletedVirtualFn = 0; for (unsigned I = 0; I != NumComponents; ++I) { VTableComponent Component = Components[I]; llvm::Constant *Init = 0; switch (Component.getKind()) { case VTableComponent::CK_VCallOffset: Init = llvm::ConstantInt::get(PtrDiffTy, Component.getVCallOffset().getQuantity()); Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy); break; case VTableComponent::CK_VBaseOffset: Init = llvm::ConstantInt::get(PtrDiffTy, Component.getVBaseOffset().getQuantity()); Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy); break; case VTableComponent::CK_OffsetToTop: Init = llvm::ConstantInt::get(PtrDiffTy, Component.getOffsetToTop().getQuantity()); Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy); break; case VTableComponent::CK_RTTI: Init = llvm::ConstantExpr::getBitCast(RTTI, Int8PtrTy); break; case VTableComponent::CK_FunctionPointer: case VTableComponent::CK_CompleteDtorPointer: case VTableComponent::CK_DeletingDtorPointer: { GlobalDecl GD; // Get the right global decl. switch (Component.getKind()) { default: llvm_unreachable("Unexpected vtable component kind"); case VTableComponent::CK_FunctionPointer: GD = Component.getFunctionDecl(); break; case VTableComponent::CK_CompleteDtorPointer: GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Complete); break; case VTableComponent::CK_DeletingDtorPointer: GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Deleting); break; } if (cast(GD.getDecl())->isPure()) { // We have a pure virtual member function. if (!PureVirtualFn) { llvm::FunctionType *Ty = llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false); StringRef PureCallName = CGM.getCXXABI().GetPureVirtualCallName(); PureVirtualFn = CGM.CreateRuntimeFunction(Ty, PureCallName); PureVirtualFn = llvm::ConstantExpr::getBitCast(PureVirtualFn, CGM.Int8PtrTy); } Init = PureVirtualFn; } else if (cast(GD.getDecl())->isDeleted()) { if (!DeletedVirtualFn) { llvm::FunctionType *Ty = llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false); StringRef DeletedCallName = CGM.getCXXABI().GetDeletedVirtualCallName(); DeletedVirtualFn = CGM.CreateRuntimeFunction(Ty, DeletedCallName); DeletedVirtualFn = llvm::ConstantExpr::getBitCast(DeletedVirtualFn, CGM.Int8PtrTy); } Init = DeletedVirtualFn; } else { // Check if we should use a thunk. if (NextVTableThunkIndex < NumVTableThunks && VTableThunks[NextVTableThunkIndex].first == I) { const ThunkInfo &Thunk = VTableThunks[NextVTableThunkIndex].second; maybeEmitThunkForVTable(GD, Thunk); Init = CGM.GetAddrOfThunk(GD, Thunk); NextVTableThunkIndex++; } else { llvm::Type *Ty = CGM.getTypes().GetFunctionTypeForVTable(GD); Init = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true); } Init = llvm::ConstantExpr::getBitCast(Init, Int8PtrTy); } break; } case VTableComponent::CK_UnusedFunctionPointer: Init = llvm::ConstantExpr::getNullValue(Int8PtrTy); break; }; Inits.push_back(Init); } llvm::ArrayType *ArrayType = llvm::ArrayType::get(Int8PtrTy, NumComponents); return llvm::ConstantArray::get(ArrayType, Inits); } llvm::GlobalVariable * CodeGenVTables::GenerateConstructionVTable(const CXXRecordDecl *RD, const BaseSubobject &Base, bool BaseIsVirtual, llvm::GlobalVariable::LinkageTypes Linkage, VTableAddressPointsMapTy& AddressPoints) { if (CGDebugInfo *DI = CGM.getModuleDebugInfo()) DI->completeClassData(Base.getBase()); OwningPtr VTLayout( getItaniumVTableContext().createConstructionVTableLayout( Base.getBase(), Base.getBaseOffset(), BaseIsVirtual, RD)); // Add the address points. AddressPoints = VTLayout->getAddressPoints(); // Get the mangled construction vtable name. SmallString<256> OutName; llvm::raw_svector_ostream Out(OutName); cast(CGM.getCXXABI().getMangleContext()) .mangleCXXCtorVTable(RD, Base.getBaseOffset().getQuantity(), Base.getBase(), Out); Out.flush(); StringRef Name = OutName.str(); llvm::ArrayType *ArrayType = llvm::ArrayType::get(CGM.Int8PtrTy, VTLayout->getNumVTableComponents()); // Construction vtable symbols are not part of the Itanium ABI, so we cannot // guarantee that they actually will be available externally. Instead, when // emitting an available_externally VTT, we provide references to an internal // linkage construction vtable. The ABI only requires complete-object vtables // to be the same for all instances of a type, not construction vtables. if (Linkage == llvm::GlobalVariable::AvailableExternallyLinkage) Linkage = llvm::GlobalVariable::InternalLinkage; // Create the variable that will hold the construction vtable. llvm::GlobalVariable *VTable = CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType, Linkage); CGM.setGlobalVisibility(VTable, RD); // V-tables are always unnamed_addr. VTable->setUnnamedAddr(true); // Create and set the initializer. llvm::Constant *Init = CreateVTableInitializer(Base.getBase(), VTLayout->vtable_component_begin(), VTLayout->getNumVTableComponents(), VTLayout->vtable_thunk_begin(), VTLayout->getNumVTableThunks()); VTable->setInitializer(Init); return VTable; } /// Compute the required linkage of the v-table for the given class. /// /// Note that we only call this at the end of the translation unit. llvm::GlobalVariable::LinkageTypes CodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) { if (!RD->isExternallyVisible()) return llvm::GlobalVariable::InternalLinkage; // We're at the end of the translation unit, so the current key // function is fully correct. if (const CXXMethodDecl *keyFunction = Context.getCurrentKeyFunction(RD)) { // If this class has a key function, use that to determine the // linkage of the vtable. const FunctionDecl *def = 0; if (keyFunction->hasBody(def)) keyFunction = cast(def); switch (keyFunction->getTemplateSpecializationKind()) { case TSK_Undeclared: case TSK_ExplicitSpecialization: assert(def && "Should not have been asked to emit this"); if (keyFunction->isInlined()) return !Context.getLangOpts().AppleKext ? llvm::GlobalVariable::LinkOnceODRLinkage : llvm::Function::InternalLinkage; return llvm::GlobalVariable::ExternalLinkage; case TSK_ImplicitInstantiation: return !Context.getLangOpts().AppleKext ? llvm::GlobalVariable::LinkOnceODRLinkage : llvm::Function::InternalLinkage; case TSK_ExplicitInstantiationDefinition: return !Context.getLangOpts().AppleKext ? llvm::GlobalVariable::WeakODRLinkage : llvm::Function::InternalLinkage; case TSK_ExplicitInstantiationDeclaration: llvm_unreachable("Should not have been asked to emit this"); } } // -fapple-kext mode does not support weak linkage, so we must use // internal linkage. if (Context.getLangOpts().AppleKext) return llvm::Function::InternalLinkage; switch (RD->getTemplateSpecializationKind()) { case TSK_Undeclared: case TSK_ExplicitSpecialization: case TSK_ImplicitInstantiation: return llvm::GlobalVariable::LinkOnceODRLinkage; case TSK_ExplicitInstantiationDeclaration: llvm_unreachable("Should not have been asked to emit this"); case TSK_ExplicitInstantiationDefinition: return llvm::GlobalVariable::WeakODRLinkage; } llvm_unreachable("Invalid TemplateSpecializationKind!"); } /// This is a callback from Sema to tell us that it believes that a /// particular v-table is required to be emitted in this translation /// unit. /// /// The reason we don't simply trust this callback is because Sema /// will happily report that something is used even when it's used /// only in code that we don't actually have to emit. /// /// \param isRequired - if true, the v-table is mandatory, e.g. /// because the translation unit defines the key function void CodeGenModule::EmitVTable(CXXRecordDecl *theClass, bool isRequired) { if (!isRequired) return; VTables.GenerateClassData(theClass); } void CodeGenVTables::GenerateClassData(const CXXRecordDecl *RD) { if (CGDebugInfo *DI = CGM.getModuleDebugInfo()) DI->completeClassData(RD); if (RD->getNumVBases()) CGM.getCXXABI().emitVirtualInheritanceTables(RD); CGM.getCXXABI().emitVTableDefinitions(*this, RD); } /// At this point in the translation unit, does it appear that can we /// rely on the vtable being defined elsewhere in the program? /// /// The response is really only definitive when called at the end of /// the translation unit. /// /// The only semantic restriction here is that the object file should /// not contain a v-table definition when that v-table is defined /// strongly elsewhere. Otherwise, we'd just like to avoid emitting /// v-tables when unnecessary. bool CodeGenVTables::isVTableExternal(const CXXRecordDecl *RD) { assert(RD->isDynamicClass() && "Non-dynamic classes have no VTable."); // If we have an explicit instantiation declaration (and not a // definition), the v-table is defined elsewhere. TemplateSpecializationKind TSK = RD->getTemplateSpecializationKind(); if (TSK == TSK_ExplicitInstantiationDeclaration) return true; // Otherwise, if the class is an instantiated template, the // v-table must be defined here. if (TSK == TSK_ImplicitInstantiation || TSK == TSK_ExplicitInstantiationDefinition) return false; // Otherwise, if the class doesn't have a key function (possibly // anymore), the v-table must be defined here. const CXXMethodDecl *keyFunction = CGM.getContext().getCurrentKeyFunction(RD); if (!keyFunction) return false; // Otherwise, if we don't have a definition of the key function, the // v-table must be defined somewhere else. return !keyFunction->hasBody(); } /// Given that we're currently at the end of the translation unit, and /// we've emitted a reference to the v-table for this class, should /// we define that v-table? static bool shouldEmitVTableAtEndOfTranslationUnit(CodeGenModule &CGM, const CXXRecordDecl *RD) { return !CGM.getVTables().isVTableExternal(RD); } /// Given that at some point we emitted a reference to one or more /// v-tables, and that we are now at the end of the translation unit, /// decide whether we should emit them. void CodeGenModule::EmitDeferredVTables() { #ifndef NDEBUG // Remember the size of DeferredVTables, because we're going to assume // that this entire operation doesn't modify it. size_t savedSize = DeferredVTables.size(); #endif typedef std::vector::const_iterator const_iterator; for (const_iterator i = DeferredVTables.begin(), e = DeferredVTables.end(); i != e; ++i) { const CXXRecordDecl *RD = *i; if (shouldEmitVTableAtEndOfTranslationUnit(*this, RD)) VTables.GenerateClassData(RD); } assert(savedSize == DeferredVTables.size() && "deferred extra v-tables during v-table emission?"); DeferredVTables.clear(); } @