22#include "llvm/IR/IntrinsicInst.h"
23#include "llvm/Support/Format.h"
24#include "llvm/Transforms/Utils/Cloning.h"
30using namespace CodeGen;
33 : CGM(CGM), VTContext(CGM.getContext().getVTableContext()) {}
37 return GetOrCreateLLVMFunction(Name, FnTy, GD,
true,
42 llvm::Function *ThunkFn,
bool ForVTable,
52 ThunkFn->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
53 ThunkFn->setDSOLocal(
true);
57 ThunkFn->setComdat(CGM.
getModule().getOrInsertComdat(ThunkFn->getName()));
65 (isa<PointerType>(typeL) && isa<PointerType>(typeR)) ||
66 (isa<ReferenceType>(typeL) && isa<ReferenceType>(typeR))));
76 llvm::BasicBlock *AdjustNull =
nullptr;
77 llvm::BasicBlock *AdjustNotNull =
nullptr;
78 llvm::BasicBlock *AdjustEnd =
nullptr;
100 if (NullCheckValue) {
101 CGF.
Builder.CreateBr(AdjustEnd);
103 CGF.
Builder.CreateBr(AdjustEnd);
106 llvm::PHINode *PHI = CGF.
Builder.CreatePHI(ReturnValue->getType(), 2);
107 PHI->addIncoming(ReturnValue, AdjustNotNull);
108 PHI->addIncoming(llvm::Constant::getNullValue(ReturnValue->getType()),
122 llvm::ValueToValueMapTy &VMap) {
124 auto *DIS = Fn->getSubprogram();
127 auto *NewDIS = DIS->replaceWithDistinct(DIS->clone());
128 VMap.MD()[DIS].reset(NewDIS);
132 for (
auto &BB : *Fn) {
134 if (
auto *DII = dyn_cast<llvm::DbgVariableIntrinsic>(&I)) {
135 auto *DILocal = DII->getVariable();
136 if (!DILocal->isResolved())
171 llvm::Function *BaseFn = cast<llvm::Function>(Callee);
180 assert(!BaseFn->isDeclaration() &&
"cannot clone undefined variadic method");
183 llvm::ValueToValueMapTy VMap;
188 llvm::Function *NewFn = llvm::CloneFunction(BaseFn, VMap);
189 Fn->replaceAllUsesWith(NewFn);
191 Fn->eraseFromParent();
198 llvm::Function::arg_iterator AI = Fn->arg_begin();
207 llvm::BasicBlock *EntryBB = &Fn->front();
208 llvm::BasicBlock::iterator ThisStore =
209 llvm::find_if(*EntryBB, [&](llvm::Instruction &I) {
210 return isa<llvm::StoreInst>(I) && I.getOperand(0) == &*AI;
212 assert(ThisStore != EntryBB->end() &&
213 "Store of this should be in entry block?");
215 Builder.SetInsertPoint(&*ThisStore);
216 llvm::Value *AdjustedThisPtr =
218 AdjustedThisPtr =
Builder.CreateBitCast(AdjustedThisPtr,
219 ThisStore->getOperand(0)->getType());
220 ThisStore->setOperand(0, AdjustedThisPtr);
224 for (llvm::BasicBlock &BB : *Fn) {
225 llvm::Instruction *
T = BB.getTerminator();
226 if (isa<llvm::ReturnInst>(
T)) {
228 T->eraseFromParent();
242 bool IsUnprototyped) {
254 ResultType = ThisType;
265 if (!IsUnprototyped) {
268 if (isa<CXXDestructorDecl>(MD))
282 CXXThisValue = CXXABIThisValue;
298 bool IsUnprototyped) {
300 "Please use a new CGF for this thunk");
304 llvm::Value *AdjustedThisPtr =
316 MD,
"return-adjusting thunk with incomplete parameter type");
318 llvm_unreachable(
"shouldn't try to emit musttail return-adjusting "
319 "thunks for variadic functions");
322 MD,
"non-trivial argument copy for return-adjusting thunk");
333 if (isa<CXXDestructorDecl>(MD))
337 unsigned PrefixArgs = CallArgs.size() - 1;
351 assert(isa<CXXDestructorDecl>(MD) ||
352 similar(CallFnInfo.getReturnInfo(), CallFnInfo.getReturnType(),
356 assert(
similar(CallFnInfo.arg_begin()[i].info,
357 CallFnInfo.arg_begin()[i].type,
376 llvm::CallBase *CallOrInvoke;
378 CallArgs, &CallOrInvoke);
383 else if (llvm::CallInst*
Call = dyn_cast<llvm::CallInst>(CallOrInvoke))
384 Call->setTailCallKind(llvm::CallInst::TCK_Tail);
397 llvm::Value *AdjustedThisPtr,
398 llvm::FunctionCallee Callee) {
410 llvm::Type *ThisType = Args[ThisArgNo]->getType();
411 if (ThisType != AdjustedThisPtr->getType())
412 AdjustedThisPtr =
Builder.CreateBitCast(AdjustedThisPtr, ThisType);
413 Args[ThisArgNo] = AdjustedThisPtr;
415 assert(ThisAI.
isInAlloca() &&
"this is passed directly or inalloca");
418 if (ThisType != AdjustedThisPtr->getType())
419 AdjustedThisPtr =
Builder.CreateBitCast(AdjustedThisPtr, ThisType);
425 llvm::CallInst *
Call =
Builder.CreateCall(Callee, Args);
426 Call->setTailCallKind(llvm::CallInst::TCK_MustTail);
430 llvm::AttributeList Attrs;
434 Call->setAttributes(Attrs);
437 if (
Call->getType()->isVoidTy())
452 bool IsUnprototyped) {
469 &Thunk, IsUnprototyped);
473 bool IsUnprototyped,
bool ForVTable) {
490llvm::Constant *CodeGenVTables::maybeEmitThunk(
GlobalDecl GD,
500 llvm::raw_svector_ostream Out(Name);
506 llvm::Constant *Thunk = CGM.
GetAddrOfThunk(Name, ThunkVTableTy, GD);
523 llvm::Function *ThunkFn = cast<llvm::Function>(Thunk->stripPointerCasts());
524 if (ThunkFn->getFunctionType() != ThunkFnTy) {
525 llvm::GlobalValue *OldThunkFn = ThunkFn;
527 assert(OldThunkFn->isDeclaration() &&
"Shouldn't replace non-declaration");
530 OldThunkFn->setName(StringRef());
531 ThunkFn = llvm::Function::Create(ThunkFnTy, llvm::Function::ExternalLinkage,
535 if (!OldThunkFn->use_empty()) {
536 OldThunkFn->replaceAllUsesWith(ThunkFn);
540 OldThunkFn->eraseFromParent();
544 bool UseAvailableExternallyLinkage = ForVTable && ABIHasKeyFunctions;
546 if (!ThunkFn->isDeclaration()) {
547 if (!ABIHasKeyFunctions || UseAvailableExternallyLinkage) {
561 ThunkFn->addFnAttr(
"thunk");
570 bool ShouldCloneVarArgs =
false;
571 if (!IsUnprototyped && ThunkFn->isVarArg()) {
572 ShouldCloneVarArgs =
true;
575 case llvm::Triple::x86_64:
576 case llvm::Triple::x86:
577 case llvm::Triple::aarch64:
578 ShouldCloneVarArgs =
false;
586 if (ShouldCloneVarArgs) {
587 if (UseAvailableExternallyLinkage)
611 if (!ThunkInfoVector)
614 for (
const ThunkInfo& Thunk : *ThunkInfoVector)
615 maybeEmitThunk(GD, Thunk,
false);
619 llvm::Constant *component,
620 unsigned vtableAddressPoint,
621 bool vtableHasLocalLinkage,
622 bool isCompleteDtor)
const {
624 if (component->isNullValue())
625 return builder.add(llvm::ConstantInt::get(CGM.
Int32Ty, 0));
628 cast<llvm::GlobalValue>(component->stripPointerCastsAndAliases());
642 auto stubLinkage = vtableHasLocalLinkage
643 ? llvm::GlobalValue::InternalLinkage
644 : llvm::GlobalValue::LinkOnceODRLinkage;
646 llvm::Constant *target;
647 if (
auto *func = dyn_cast<llvm::Function>(globalVal)) {
648 target = llvm::DSOLocalEquivalent::get(func);
651 rttiProxyName.append(
".rtti_proxy");
657 llvm::GlobalVariable *proxy = module.getNamedGlobal(rttiProxyName);
659 proxy =
new llvm::GlobalVariable(module, globalVal->getType(),
661 globalVal, rttiProxyName);
662 proxy->setDSOLocal(
true);
663 proxy->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
664 if (!proxy->hasLocalLinkage()) {
665 proxy->setVisibility(llvm::GlobalValue::HiddenVisibility);
666 proxy->setComdat(module.getOrInsertComdat(rttiProxyName));
678 builder.addRelativeOffsetToPosition(CGM.
Int32Ty, target,
687bool CodeGenVTables::useRelativeLayout()
const {
697llvm::Type *CodeGenVTables::getVTableComponentType()
const {
704 builder.add(llvm::ConstantExpr::getIntToPtr(
717 unsigned componentIndex,
718 llvm::Constant *rtti,
719 unsigned &nextVTableThunkIndex,
720 unsigned vtableAddressPoint,
721 bool vtableHasLocalLinkage) {
724 auto addOffsetConstant =
727 switch (component.getKind()) {
729 return addOffsetConstant(CGM, builder, component.getVCallOffset());
732 return addOffsetConstant(CGM, builder, component.getVBaseOffset());
735 return addOffsetConstant(CGM, builder, component.getOffsetToTop());
738 if (useRelativeLayout())
739 return addRelativeComponent(builder, rtti, vtableAddressPoint,
740 vtableHasLocalLinkage,
743 return builder.add(rtti);
759 ? MD->
hasAttr<CUDADeviceAttr>()
760 : (MD->
hasAttr<CUDAHostAttr>() || !MD->
hasAttr<CUDADeviceAttr>());
767 auto getSpecialVirtualFn = [&](StringRef
name) -> llvm::Constant * {
775 if (useRelativeLayout())
783 llvm::FunctionType *fnTy =
784 llvm::FunctionType::get(CGM.
VoidTy,
false);
785 llvm::Constant *fn = cast<llvm::Constant>(
787 if (
auto f = dyn_cast<llvm::Function>(fn))
788 f->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
792 llvm::Constant *fnPtr;
795 if (cast<CXXMethodDecl>(GD.
getDecl())->isPureVirtual()) {
799 fnPtr = PureVirtualFn;
802 }
else if (cast<CXXMethodDecl>(GD.
getDecl())->isDeleted()) {
803 if (!DeletedVirtualFn)
806 fnPtr = DeletedVirtualFn;
809 }
else if (nextVTableThunkIndex < layout.
vtable_thunks().size() &&
812 auto &thunkInfo = layout.
vtable_thunks()[nextVTableThunkIndex].second;
814 nextVTableThunkIndex++;
815 fnPtr = maybeEmitThunk(GD, thunkInfo,
true);
823 if (useRelativeLayout()) {
824 return addRelativeComponent(
825 builder, fnPtr, vtableAddressPoint, vtableHasLocalLinkage,
832 unsigned FnAS = fnPtr->getType()->getPointerAddressSpace();
838 return builder.add(fnPtr);
843 if (useRelativeLayout())
844 return builder.add(llvm::ConstantExpr::getNullValue(CGM.
Int32Ty));
849 llvm_unreachable(
"Unexpected vtable component kind");
854 llvm::Type *componentType = getVTableComponentType();
855 for (
unsigned i = 0, e = layout.
getNumVTables(); i != e; ++i)
856 tys.push_back(llvm::ArrayType::get(componentType, layout.
getVTableSize(i)));
863 llvm::Constant *rtti,
864 bool vtableHasLocalLinkage) {
865 llvm::Type *componentType = getVTableComponentType();
868 unsigned nextVTableThunkIndex = 0;
869 for (
unsigned vtableIndex = 0, endIndex = layout.
getNumVTables();
870 vtableIndex != endIndex; ++vtableIndex) {
871 auto vtableElem = builder.
beginArray(componentType);
874 size_t vtableEnd = vtableStart + layout.
getVTableSize(vtableIndex);
875 for (
size_t componentIndex = vtableStart; componentIndex < vtableEnd;
877 addVTableComponent(vtableElem, layout, componentIndex, rtti,
878 nextVTableThunkIndex, addressPoints[vtableIndex],
879 vtableHasLocalLinkage);
881 vtableElem.finishAndAddTo(builder);
887 llvm::GlobalVariable::LinkageTypes
Linkage,
888 VTableAddressPointsMapTy &AddressPoints) {
890 DI->completeClassData(
Base.getBase());
892 std::unique_ptr<VTableLayout> VTLayout(
894 Base.getBase(),
Base.getBaseOffset(), BaseIsVirtual, RD));
897 AddressPoints = VTLayout->getAddressPoints();
901 llvm::raw_svector_ostream Out(OutName);
903 .mangleCXXCtorVTable(RD,
Base.getBaseOffset().getQuantity(),
904 Base.getBase(), Out);
908 bool VTableAliasExists =
909 UsingRelativeLayout && CGM.
getModule().getNamedAlias(Name);
910 if (VTableAliasExists) {
912 Name.append(
".local");
922 if (
Linkage == llvm::GlobalVariable::AvailableExternallyLinkage)
923 Linkage = llvm::GlobalVariable::InternalLinkage;
925 llvm::Align Align = CGM.
getDataLayout().getABITypeAlign(VTType);
928 llvm::GlobalVariable *VTable =
932 VTable->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
941 VTable->hasLocalLinkage());
942 components.finishAndSetAsInitializer(VTable);
946 assert(!VTable->isDeclaration() &&
"Shouldn't set properties on declaration");
951 if (UsingRelativeLayout) {
953 if (!VTable->isDSOLocal())
970 llvm::GlobalValue::SanitizerMetadata Meta;
971 if (GV->hasSanitizerMetadata())
972 Meta = GV->getSanitizerMetadata();
973 Meta.NoHWAddress =
true;
974 GV->setSanitizerMetadata(Meta);
985 llvm::StringRef AliasNameRef) {
987 "Can only use this if the relative vtable ABI is used");
988 assert(!VTable->isDSOLocal() &&
"This should be called only if the vtable is "
989 "not guaranteed to be dso_local");
994 if (VTable->hasAvailableExternallyLinkage())
1001 VTable->setName(AliasName +
".local");
1003 auto Linkage = VTable->getLinkage();
1004 assert(llvm::GlobalAlias::isValidLinkage(
Linkage) &&
1005 "Invalid vtable alias linkage");
1007 llvm::GlobalAlias *VTableAlias = CGM.
getModule().getNamedAlias(AliasName);
1009 VTableAlias = llvm::GlobalAlias::create(VTable->getValueType(),
1010 VTable->getAddressSpace(),
Linkage,
1013 assert(VTableAlias->getValueType() == VTable->getValueType());
1014 assert(VTableAlias->getLinkage() ==
Linkage);
1016 VTableAlias->setVisibility(VTable->getVisibility());
1017 VTableAlias->setUnnamedAddr(VTable->getUnnamedAddr());
1020 if (!VTable->hasComdat()) {
1025 VTable->setLinkage(llvm::GlobalValue::PrivateLinkage);
1028 VTable->setVisibility(llvm::GlobalValue::HiddenVisibility);
1031 VTableAlias->setAliasee(VTable);
1043llvm::GlobalVariable::LinkageTypes
1046 return llvm::GlobalVariable::InternalLinkage;
1051 if (keyFunction && !RD->
hasAttr<DLLImportAttr>()) {
1055 if (keyFunction->
hasBody(def))
1056 keyFunction = cast<CXXMethodDecl>(def);
1062 (def || CodeGenOpts.OptimizationLevel > 0 ||
1063 CodeGenOpts.getDebugInfo() != llvm::codegenoptions::NoDebugInfo) &&
1064 "Shouldn't query vtable linkage without key function, "
1065 "optimizations, or debug info");
1066 if (!def && CodeGenOpts.OptimizationLevel > 0)
1067 return llvm::GlobalVariable::AvailableExternallyLinkage;
1071 ? llvm::GlobalVariable::LinkOnceODRLinkage
1072 : llvm::Function::InternalLinkage;
1074 return llvm::GlobalVariable::ExternalLinkage;
1078 llvm::GlobalVariable::LinkOnceODRLinkage :
1079 llvm::Function::InternalLinkage;
1083 llvm::GlobalVariable::WeakODRLinkage :
1084 llvm::Function::InternalLinkage;
1087 llvm_unreachable(
"Should not have been asked to emit this");
1094 return llvm::Function::InternalLinkage;
1096 llvm::GlobalVariable::LinkageTypes DiscardableODRLinkage =
1097 llvm::GlobalValue::LinkOnceODRLinkage;
1098 llvm::GlobalVariable::LinkageTypes NonDiscardableODRLinkage =
1099 llvm::GlobalValue::WeakODRLinkage;
1100 if (RD->
hasAttr<DLLExportAttr>()) {
1102 DiscardableODRLinkage = NonDiscardableODRLinkage;
1103 }
else if (RD->
hasAttr<DLLImportAttr>()) {
1105 DiscardableODRLinkage = llvm::GlobalVariable::AvailableExternallyLinkage;
1106 NonDiscardableODRLinkage = llvm::GlobalVariable::AvailableExternallyLinkage;
1113 return DiscardableODRLinkage;
1119 return DiscardableODRLinkage;
1121 ? llvm::GlobalVariable::AvailableExternallyLinkage
1122 : llvm::GlobalVariable::ExternalLinkage;
1125 return NonDiscardableODRLinkage;
1128 llvm_unreachable(
"Invalid TemplateSpecializationKind!");
1144 DI->completeClassData(RD);
1163 assert(RD->
isDynamicClass() &&
"Non-dynamic classes have no VTable.");
1191 if (!keyFunction->
hasBody(Def))
1194 assert(Def &&
"The body of the key function is not assigned to Def?");
1216void CodeGenModule::EmitDeferredVTables() {
1220 size_t savedSize = DeferredVTables.size();
1226 else if (shouldOpportunisticallyEmitVTables())
1227 OpportunisticVTables.push_back(RD);
1229 assert(savedSize == DeferredVTables.size() &&
1230 "deferred extra vtables during vtable emission?");
1231 DeferredVTables.clear();
1235 if (RD->
hasAttr<LTOVisibilityPublicAttr>() || RD->
hasAttr<UuidAttr>() ||
1244 auto *D = cast<Decl>(DC);
1247 if (
auto *ND = dyn_cast<NamespaceDecl>(D))
1249 if (II->isStr(
"std") || II->isStr(
"stdext"))
1277 if (!
Visited.insert(RD).second)
1278 return llvm::GlobalObject::VCallVisibilityTranslationUnit;
1281 llvm::GlobalObject::VCallVisibility TypeVis;
1283 TypeVis = llvm::GlobalObject::VCallVisibilityTranslationUnit;
1285 TypeVis = llvm::GlobalObject::VCallVisibilityLinkageUnit;
1287 TypeVis = llvm::GlobalObject::VCallVisibilityPublic;
1289 for (
const auto &B : RD->
bases())
1290 if (B.getType()->getAsCXXRecordDecl()->isDynamicClass())
1295 for (
const auto &B : RD->
vbases())
1296 if (B.getType()->getAsCXXRecordDecl()->isDynamicClass())
1305 llvm::GlobalVariable *VTable,
1315 struct AddressPoint {
1319 bool operator<(
const AddressPoint &RHS)
const {
1320 int D =
TypeName.compare(RHS.TypeName);
1321 return D < 0 || (D == 0 && Offset < RHS.Offset);
1324 std::vector<AddressPoint> AddressPoints;
1326 AddressPoint N{AP.first.getBase(),
1328 AP.second.AddressPointIndex,
1330 llvm::raw_string_ostream Stream(N.TypeName);
1332 QualType(N.Base->getTypeForDecl(), 0), Stream);
1333 AddressPoints.push_back(std::move(N));
1337 llvm::sort(AddressPoints);
1340 for (
auto AP : AddressPoints) {
1348 for (
unsigned I = 0; I != Comps.size(); ++I) {
1353 Comps[I].getFunctionDecl()->getType(),
1355 VTable->addTypeMetadata((ComponentWidth * I).getQuantity(), MD);
1362 llvm::GlobalObject::VCallVisibility TypeVis =
1364 if (TypeVis != llvm::GlobalObject::VCallVisibilityPublic)
1365 VTable->setVCallVisibilityMetadata(TypeVis);
static RValue PerformReturnAdjustment(CodeGenFunction &CGF, QualType ResultType, RValue RV, const ThunkInfo &Thunk)
static void setThunkProperties(CodeGenModule &CGM, const ThunkInfo &Thunk, llvm::Function *ThunkFn, bool ForVTable, GlobalDecl GD)
static bool shouldEmitVTableThunk(CodeGenModule &CGM, const CXXMethodDecl *MD, bool IsUnprototyped, bool ForVTable)
static void resolveTopLevelMetadata(llvm::Function *Fn, llvm::ValueToValueMapTy &VMap)
This function clones a function's DISubprogram node and enters it into a value map with the intent th...
static bool shouldEmitAvailableExternallyVTable(const CodeGenModule &CGM, const CXXRecordDecl *RD)
static bool shouldEmitVTableAtEndOfTranslationUnit(CodeGenModule &CGM, const CXXRecordDecl *RD)
Given that we're currently at the end of the translation unit, and we've emitted a reference to the v...
static void AddRelativeLayoutOffset(const CodeGenModule &CGM, ConstantArrayBuilder &builder, CharUnits offset)
static void AddPointerLayoutOffset(const CodeGenModule &CGM, ConstantArrayBuilder &builder, CharUnits offset)
static bool similar(const ABIArgInfo &infoL, CanQualType typeL, const ABIArgInfo &infoR, CanQualType typeR)
static bool UseRelativeLayout(const CodeGenModule &CGM)
static Decl::Kind getKind(const Decl *D)
llvm::DenseSet< const void * > Visited
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
QualType getRecordType(const RecordDecl *Decl) const
const CXXMethodDecl * getCurrentKeyFunction(const CXXRecordDecl *RD)
Get our current best idea for the key function of the given record decl, or nullptr if there isn't on...
const LangOptions & getLangOpts() const
Represents a C++ destructor within a class.
Represents a static or instance method of a struct/union/class.
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
QualType getThisType() const
Return the type of the this pointer.
QualType getFunctionObjectParameterType() const
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Represents a C++ struct/union/class.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
base_class_range vbases()
bool isDynamicClass() const
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
CharUnits - This is an opaque type for sizes expressed in character units.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
ABIArgInfo - Helper class to encapsulate information about how a specific C type should be passed to ...
@ Indirect
Indirect - Pass the argument indirectly via a hidden pointer with the specified alignment (0 indicate...
bool isSRetAfterThis() const
Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this ...
llvm::Type * getElementType() const
Return the type of the values stored in this address.
static ApplyDebugLocation CreateArtificial(CodeGenFunction &CGF)
Apply TemporaryLocation if it is valid.
static ApplyDebugLocation CreateEmpty(CodeGenFunction &CGF)
Set the IRBuilder to not attach debug locations.
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
llvm::Value * CreateIsNull(Address Addr, const Twine &Name="")
virtual bool hasMostDerivedReturn(GlobalDecl GD) const
virtual llvm::Value * performReturnAdjustment(CodeGenFunction &CGF, Address Ret, const ReturnAdjustment &RA)=0
virtual bool HasThisReturn(GlobalDecl GD) const
Returns true if the given constructor or destructor is one of the kinds that the ABI says returns 'th...
virtual void EmitInstanceFunctionProlog(CodeGenFunction &CGF)=0
Emit the ABI-specific prolog for the function.
virtual StringRef GetPureVirtualCallName()=0
Gets the pure virtual member call function.
virtual void EmitReturnFromThunk(CodeGenFunction &CGF, RValue RV, QualType ResultType)
virtual bool canSpeculativelyEmitVTable(const CXXRecordDecl *RD) const =0
Determine whether it's possible to emit a vtable for RD, even though we do not know that the vtable h...
virtual StringRef GetDeletedVirtualCallName()=0
Gets the deleted virtual member call name.
void buildThisParam(CodeGenFunction &CGF, FunctionArgList &Params)
Build a parameter variable suitable for 'this'.
virtual void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy, FunctionArgList &Params)=0
Insert any ABI-specific implicit parameters into the parameter list for a function.
virtual void setThunkLinkage(llvm::Function *Thunk, bool ForVTable, GlobalDecl GD, bool ReturnAdjustment)=0
virtual void adjustCallArgsForDestructorThunk(CodeGenFunction &CGF, GlobalDecl GD, CallArgList &CallArgs)
virtual void emitVirtualInheritanceTables(const CXXRecordDecl *RD)=0
Emit any tables needed to implement virtual inheritance.
virtual void emitVTableDefinitions(CodeGenVTables &CGVT, const CXXRecordDecl *RD)=0
Emits the VTable definitions required for the given record type.
virtual bool exportThunk()=0
virtual llvm::Value * performThisAdjustment(CodeGenFunction &CGF, Address This, const ThisAdjustment &TA)=0
MangleContext & getMangleContext()
Gets the mangle context.
static CGCallee forDirect(llvm::Constant *functionPtr, const CGCalleeInfo &abstractInfo=CGCalleeInfo())
This class gathers all debug information during compilation and is responsible for emitting to llvm g...
CGFunctionInfo - Class to encapsulate the information about a function definition.
bool usesInAlloca() const
Return true if this function uses inalloca arguments.
ABIArgInfo & getReturnInfo()
unsigned getCallingConvention() const
getCallingConvention - Return the user specified calling convention, which has been translated into a...
const_arg_iterator arg_begin() const
unsigned getRegParm() const
CanQualType getReturnType() const
unsigned arg_size() const
CallArgList - Type for representing both the value and type of arguments in a call.
void add(RValue rvalue, QualType type)
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
void FinishFunction(SourceLocation EndLoc=SourceLocation())
FinishFunction - Complete IR generation of the current function.
GlobalDecl CurGD
CurGD - The GlobalDecl for the current function being compiled.
void EmitCallAndReturnForThunk(llvm::FunctionCallee Callee, const ThunkInfo *Thunk, bool IsUnprototyped)
llvm::Function * GenerateVarArgsThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo, GlobalDecl GD, const ThunkInfo &Thunk)
void generateThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo, GlobalDecl GD, const ThunkInfo &Thunk, bool IsUnprototyped)
Generate a thunk for the given method.
bool CurFuncIsThunk
In C++, whether we are code generating a thunk.
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
Address makeNaturalAddressForPointer(llvm::Value *Ptr, QualType T, CharUnits Alignment=CharUnits::Zero(), bool ForPointeeType=false, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)
Construct an address with the natural alignment of T.
RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::CallBase **callOrInvoke, bool IsMustTail, SourceLocation Loc)
EmitCall - Generate a call of the given function, expecting the given result type,...
llvm::Type * ConvertTypeForMem(QualType T)
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
void StartFunction(GlobalDecl GD, QualType RetTy, llvm::Function *Fn, const CGFunctionInfo &FnInfo, const FunctionArgList &Args, SourceLocation Loc=SourceLocation(), SourceLocation StartLoc=SourceLocation())
Emit code for the start of a function.
void EmitDelegateCallArg(CallArgList &args, const VarDecl *param, SourceLocation loc)
EmitDelegateCallArg - We are performing a delegate call; that is, the current function is delegating ...
const Decl * CurFuncDecl
CurFuncDecl - Holds the Decl for the current outermost non-closure context.
void StartThunk(llvm::Function *Fn, GlobalDecl GD, const CGFunctionInfo &FnInfo, bool IsUnprototyped)
bool AutoreleaseResult
In ARC, whether we should autorelease the return value.
Address LoadCXXThisAddress()
static bool hasAggregateEvaluationKind(QualType T)
llvm::Value * LoadCXXThis()
LoadCXXThis - Load the value of 'this'.
const CGFunctionInfo * CurFnInfo
Address GetAddrOfLocalVar(const VarDecl *VD)
GetAddrOfLocalVar - Return the address of a local variable.
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
llvm::LLVMContext & getLLVMContext()
void EmitMustTailThunk(GlobalDecl GD, llvm::Value *AdjustedThisPtr, llvm::FunctionCallee Callee)
Emit a musttail call for a thunk with a potentially adjusted this pointer.
This class organizes the cross-function state that is used while generating LLVM code.
void setGVProperties(llvm::GlobalValue *GV, GlobalDecl GD) const
Set visibility, dllimport/dllexport and dso_local.
void AddVTableTypeMetadata(llvm::GlobalVariable *VTable, CharUnits Offset, const CXXRecordDecl *RD)
Create and attach type metadata for the given vtable.
llvm::GlobalObject::VCallVisibility GetVCallVisibilityLevel(const CXXRecordDecl *RD, llvm::DenseSet< const CXXRecordDecl * > &Visited)
Returns the vcall visibility of the given type.
llvm::Module & getModule() const
llvm::FunctionCallee CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false, bool AssumeConvergent=false)
Create or return a runtime function declaration with the specified type and name.
CGDebugInfo * getModuleDebugInfo()
CodeGenVTables & getVTables()
CharUnits GetTargetTypeStoreSize(llvm::Type *Ty) const
Return the store size, in character units, of the given LLVM type.
llvm::Constant * GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH=false)
Get the address of the RTTI descriptor for the given type.
llvm::Constant * GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty=nullptr, bool ForVTable=false, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
Return the address of the given function.
void ErrorUnsupported(const Stmt *S, const char *Type)
Print out an error that codegen doesn't support the specified stmt yet.
const LangOptions & getLangOpts() const
CodeGenTypes & getTypes()
const TargetInfo & getTarget() const
void EmitVTableTypeMetadata(const CXXRecordDecl *RD, llvm::GlobalVariable *VTable, const VTableLayout &VTLayout)
Emit type metadata for the given vtable using the given layout.
bool HasHiddenLTOVisibility(const CXXRecordDecl *RD)
Returns whether the given record has hidden LTO visibility and therefore may participate in (single-m...
const llvm::DataLayout & getDataLayout() const
CGCXXABI & getCXXABI() const
CharUnits getClassPointerAlignment(const CXXRecordDecl *CD)
Returns the assumed alignment of an opaque pointer to the given class.
const llvm::Triple & getTriple() const
bool AlwaysHasLTOVisibilityPublic(const CXXRecordDecl *RD)
Returns whether the given record has public LTO visibility (regardless of -lto-whole-program-visibili...
void EmitVTable(CXXRecordDecl *Class)
This is a callback from Sema to tell us that a particular vtable is required to be emitted in this tr...
void ConstructAttributeList(StringRef Name, const CGFunctionInfo &Info, CGCalleeInfo CalleeInfo, llvm::AttributeList &Attrs, unsigned &CallingConv, bool AttrOnCallSite, bool IsThunk)
Get the LLVM attributes and calling convention to use for a particular function type.
void setFunctionLinkage(GlobalDecl GD, llvm::Function *F)
ItaniumVTableContext & getItaniumVTableContext()
ASTContext & getContext() const
llvm::Type * getVTableComponentType() const
bool supportsCOMDAT() const
bool ReturnTypeUsesSRet(const CGFunctionInfo &FI)
Return true iff the given type uses 'sret' when used as a return type.
const CodeGenOptions & getCodeGenOpts() const
llvm::GlobalVariable * CreateOrReplaceCXXRuntimeVariable(StringRef Name, llvm::Type *Ty, llvm::GlobalValue::LinkageTypes Linkage, llvm::Align Alignment)
Will return a global variable of the given type.
llvm::LLVMContext & getLLVMContext()
llvm::GlobalVariable::LinkageTypes getVTableLinkage(const CXXRecordDecl *RD)
Return the appropriate linkage for the vtable, VTT, and type information of the given class.
void SetLLVMFunctionAttributes(GlobalDecl GD, const CGFunctionInfo &Info, llvm::Function *F, bool IsThunk)
Set the LLVM function attributes (sext, zext, etc).
void SetLLVMFunctionAttributesForDefinition(const Decl *D, llvm::Function *F)
Set the LLVM function attributes which only apply to a function definition.
llvm::Metadata * CreateMetadataIdentifierForVirtualMemPtrType(QualType T)
Create a metadata identifier that is intended to be used to check virtual calls via a member function...
llvm::Constant * GetAddrOfThunk(StringRef Name, llvm::Type *FnTy, GlobalDecl GD)
Get the address of the thunk for the given global decl.
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
bool isFuncTypeConvertible(const FunctionType *FT)
isFuncTypeConvertible - Utility to check whether a function type can be converted to an LLVM type (i....
const CGFunctionInfo & arrangeGlobalDeclaration(GlobalDecl GD)
const CGFunctionInfo & arrangeUnprototypedMustTailThunk(const CXXMethodDecl *MD)
Arrange a thunk that takes 'this' as the first parameter followed by varargs.
const CGFunctionInfo & arrangeCXXMethodCall(const CallArgList &args, const FunctionProtoType *type, RequiredArgs required, unsigned numPrefixArgs)
Arrange a call to a C++ method, passing the given arguments.
llvm::Type * GetFunctionTypeForVTable(GlobalDecl GD)
GetFunctionTypeForVTable - Get the LLVM function type for use in a vtable, given a CXXMethodDecl.
void createVTableInitializer(ConstantStructBuilder &builder, const VTableLayout &layout, llvm::Constant *rtti, bool vtableHasLocalLinkage)
Add vtable components for the given vtable layout to the given global initializer.
void GenerateClassData(const CXXRecordDecl *RD)
GenerateClassData - Generate all the class data required to be generated upon definition of a KeyFunc...
void GenerateRelativeVTableAlias(llvm::GlobalVariable *VTable, llvm::StringRef AliasNameRef)
Generate a public facing alias for the vtable and make the vtable either hidden or private.
ItaniumVTableContext & getItaniumVTableContext()
CodeGenVTables(CodeGenModule &CGM)
llvm::GlobalVariable * GenerateConstructionVTable(const CXXRecordDecl *RD, const BaseSubobject &Base, bool BaseIsVirtual, llvm::GlobalVariable::LinkageTypes Linkage, VTableAddressPointsMapTy &AddressPoints)
GenerateConstructionVTable - Generate a construction vtable for the given base subobject.
llvm::Type * getVTableType(const VTableLayout &layout)
Returns the type of a vtable with the given layout.
bool isVTableExternal(const CXXRecordDecl *RD)
At this point in the translation unit, does it appear that can we rely on the vtable being defined el...
void RemoveHwasanMetadata(llvm::GlobalValue *GV) const
Specify a global should not be instrumented with hwasan.
void EmitThunks(GlobalDecl GD)
EmitThunks - Emit the associated thunks for the given global decl.
ArrayBuilder beginArray(llvm::Type *eltTy=nullptr)
A helper class of ConstantInitBuilder, used for building constant array initializers.
StructBuilder beginStruct(llvm::StructType *structTy=nullptr)
The standard implementation of ConstantInitBuilder used in Clang.
A helper class of ConstantInitBuilder, used for building constant struct initializers.
FunctionArgList - Type for representing both the decl and type of parameters to a function.
RValue - This trivial value class is used to represent the result of an expression that is evaluated.
static RValue get(llvm::Value *V)
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
static RequiredArgs forPrototypePlus(const FunctionProtoType *prototype, unsigned additional)
Compute the arguments required by the given formal prototype, given that there may be some additional...
ReturnValueSlot - Contains the address where the return value of a function can be stored,...
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
bool isInAnotherModuleUnit() const
Whether this declaration comes from another module unit.
SourceLocation getLocation() const
Represents a function declaration or definition.
param_iterator param_end()
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
ArrayRef< ParmVarDecl * > parameters() const
param_iterator param_begin()
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const
Returns true if the function has a definition that does not need to be instantiated.
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Represents a prototype with parameter type info, e.g.
FunctionType - C99 6.7.5.3 - Function Declarators.
QualType getReturnType() const
GlobalDecl - represents a global declaration.
CXXDtorType getDtorType() const
const Decl * getDecl() const
One of these records is kept for each identifier that is lexed.
bool isRelativeLayout() const
SanitizerSet Sanitize
Set of enabled sanitizers.
Visibility getVisibility() const
Linkage getLinkage() const
MangleContext - Context for tracking state which persists across multiple calls to the C++ name mangl...
virtual void mangleCXXDtorThunk(const CXXDestructorDecl *DD, CXXDtorType Type, const ThisAdjustment &ThisAdjustment, raw_ostream &)=0
virtual void mangleCanonicalTypeName(QualType T, raw_ostream &, bool NormalizeIntegers=false)=0
Generates a unique string for an externally visible type for use with TBAA or type uniquing.
virtual void mangleThunk(const CXXMethodDecl *MD, const ThunkInfo &Thunk, raw_ostream &)=0
LinkageInfo getLinkageAndVisibility() const
Determines the linkage and visibility of this entity.
bool isExternallyVisible() const
Represents a parameter to a function.
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Encodes a location in the source.
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
bool isItaniumFamily() const
Does this ABI generally fall into the Itanium family of ABIs?
bool hasKeyFunctions() const
Does this ABI use key functions? If so, class data such as the vtable is emitted with strong linkage ...
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
@ CK_DeletingDtorPointer
A pointer to the deleting destructor.
@ CK_UnusedFunctionPointer
An entry that is never used.
@ CK_CompleteDtorPointer
A pointer to the complete destructor.
virtual const ThunkInfoVectorTy * getThunkInfo(GlobalDecl GD)
const AddressPointsIndexMapTy & getAddressPointIndices() const
size_t getVTableOffset(size_t i) const
ArrayRef< VTableComponent > vtable_components() const
size_t getNumVTables() const
ArrayRef< VTableThunkTy > vtable_thunks() const
const AddressPointsMapTy & getAddressPoints() const
size_t getVTableSize(size_t i) const
The JSON file list parser is used to communicate input to InstallAPI.
bool operator<(DeclarationName LHS, DeclarationName RHS)
Ordering on two declaration names.
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
@ Dtor_Base
Base object dtor.
const FunctionProtoType * T
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
@ TSK_ExplicitInstantiationDefinition
This template specialization was instantiated from a template due to an explicit instantiation defini...
@ TSK_ExplicitInstantiationDeclaration
This template specialization was instantiated from a template due to an explicit instantiation declar...
@ TSK_ExplicitSpecialization
This template specialization was declared or defined by an explicit specialization (C++ [temp....
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
@ TSK_Undeclared
This template specialization was formed from a template-id but has not yet been declared,...
CallingConv
CallingConv - Specifies the calling convention that a function uses.
bool isExternallyVisible(Linkage L)
@ HiddenVisibility
Objects with "hidden" visibility are not seen by the dynamic linker.
llvm::PointerType * GlobalsInt8PtrTy
llvm::IntegerType * Int32Ty
llvm::IntegerType * PtrDiffTy
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.
The this pointer adjustment as well as an optional return adjustment for a thunk.
ThisAdjustment This
The this pointer adjustment.
ReturnAdjustment Return
The return adjustment.