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 for (llvm::DbgVariableRecord &DVR :
135 llvm::filterDbgVars(I.getDbgRecordRange())) {
136 auto *DILocal = DVR.getVariable();
137 if (!DILocal->isResolved())
140 if (
auto *DII = dyn_cast<llvm::DbgVariableIntrinsic>(&I)) {
141 auto *DILocal = DII->getVariable();
142 if (!DILocal->isResolved())
177 llvm::Function *BaseFn = cast<llvm::Function>(Callee);
186 assert(!BaseFn->isDeclaration() &&
"cannot clone undefined variadic method");
189 llvm::ValueToValueMapTy VMap;
194 llvm::Function *NewFn = llvm::CloneFunction(BaseFn, VMap);
195 Fn->replaceAllUsesWith(NewFn);
197 Fn->eraseFromParent();
204 llvm::Function::arg_iterator AI = Fn->arg_begin();
213 llvm::BasicBlock *EntryBB = &Fn->front();
214 llvm::BasicBlock::iterator ThisStore =
215 llvm::find_if(*EntryBB, [&](llvm::Instruction &I) {
216 return isa<llvm::StoreInst>(I) && I.getOperand(0) == &*AI;
218 assert(ThisStore != EntryBB->end() &&
219 "Store of this should be in entry block?");
221 Builder.SetInsertPoint(&*ThisStore);
222 llvm::Value *AdjustedThisPtr =
224 AdjustedThisPtr =
Builder.CreateBitCast(AdjustedThisPtr,
225 ThisStore->getOperand(0)->getType());
226 ThisStore->setOperand(0, AdjustedThisPtr);
230 for (llvm::BasicBlock &BB : *Fn) {
231 llvm::Instruction *
T = BB.getTerminator();
232 if (isa<llvm::ReturnInst>(
T)) {
234 T->eraseFromParent();
248 bool IsUnprototyped) {
260 ResultType = ThisType;
271 if (!IsUnprototyped) {
274 if (isa<CXXDestructorDecl>(MD))
288 CXXThisValue = CXXABIThisValue;
304 bool IsUnprototyped) {
306 "Please use a new CGF for this thunk");
310 llvm::Value *AdjustedThisPtr =
322 MD,
"return-adjusting thunk with incomplete parameter type");
324 llvm_unreachable(
"shouldn't try to emit musttail return-adjusting "
325 "thunks for variadic functions");
328 MD,
"non-trivial argument copy for return-adjusting thunk");
339 if (isa<CXXDestructorDecl>(MD))
343 unsigned PrefixArgs = CallArgs.size() - 1;
357 assert(isa<CXXDestructorDecl>(MD) ||
358 similar(CallFnInfo.getReturnInfo(), CallFnInfo.getReturnType(),
362 assert(
similar(CallFnInfo.arg_begin()[i].info,
363 CallFnInfo.arg_begin()[i].type,
382 llvm::CallBase *CallOrInvoke;
384 CallArgs, &CallOrInvoke);
389 else if (llvm::CallInst*
Call = dyn_cast<llvm::CallInst>(CallOrInvoke))
390 Call->setTailCallKind(llvm::CallInst::TCK_Tail);
403 llvm::Value *AdjustedThisPtr,
404 llvm::FunctionCallee Callee) {
416 llvm::Type *ThisType = Args[ThisArgNo]->getType();
417 if (ThisType != AdjustedThisPtr->getType())
418 AdjustedThisPtr =
Builder.CreateBitCast(AdjustedThisPtr, ThisType);
419 Args[ThisArgNo] = AdjustedThisPtr;
421 assert(ThisAI.
isInAlloca() &&
"this is passed directly or inalloca");
424 if (ThisType != AdjustedThisPtr->getType())
425 AdjustedThisPtr =
Builder.CreateBitCast(AdjustedThisPtr, ThisType);
431 llvm::CallInst *
Call =
Builder.CreateCall(Callee, Args);
432 Call->setTailCallKind(llvm::CallInst::TCK_MustTail);
436 llvm::AttributeList Attrs;
440 Call->setAttributes(Attrs);
443 if (
Call->getType()->isVoidTy())
458 bool IsUnprototyped) {
475 &Thunk, IsUnprototyped);
479 bool IsUnprototyped,
bool ForVTable) {
496llvm::Constant *CodeGenVTables::maybeEmitThunk(
GlobalDecl GD,
506 llvm::raw_svector_ostream Out(Name);
512 llvm::Constant *Thunk = CGM.
GetAddrOfThunk(Name, ThunkVTableTy, GD);
529 llvm::Function *ThunkFn = cast<llvm::Function>(Thunk->stripPointerCasts());
530 if (ThunkFn->getFunctionType() != ThunkFnTy) {
531 llvm::GlobalValue *OldThunkFn = ThunkFn;
533 assert(OldThunkFn->isDeclaration() &&
"Shouldn't replace non-declaration");
536 OldThunkFn->setName(StringRef());
537 ThunkFn = llvm::Function::Create(ThunkFnTy, llvm::Function::ExternalLinkage,
541 if (!OldThunkFn->use_empty()) {
542 OldThunkFn->replaceAllUsesWith(ThunkFn);
546 OldThunkFn->eraseFromParent();
550 bool UseAvailableExternallyLinkage = ForVTable && ABIHasKeyFunctions;
552 if (!ThunkFn->isDeclaration()) {
553 if (!ABIHasKeyFunctions || UseAvailableExternallyLinkage) {
567 ThunkFn->addFnAttr(
"thunk");
576 bool ShouldCloneVarArgs =
false;
577 if (!IsUnprototyped && ThunkFn->isVarArg()) {
578 ShouldCloneVarArgs =
true;
581 case llvm::Triple::x86_64:
582 case llvm::Triple::x86:
583 case llvm::Triple::aarch64:
584 ShouldCloneVarArgs =
false;
592 if (ShouldCloneVarArgs) {
593 if (UseAvailableExternallyLinkage)
617 if (!ThunkInfoVector)
620 for (
const ThunkInfo& Thunk : *ThunkInfoVector)
621 maybeEmitThunk(GD, Thunk,
false);
625 llvm::Constant *component,
626 unsigned vtableAddressPoint,
627 bool vtableHasLocalLinkage,
628 bool isCompleteDtor)
const {
630 if (component->isNullValue())
631 return builder.add(llvm::ConstantInt::get(CGM.
Int32Ty, 0));
634 cast<llvm::GlobalValue>(component->stripPointerCastsAndAliases());
648 auto stubLinkage = vtableHasLocalLinkage
649 ? llvm::GlobalValue::InternalLinkage
650 : llvm::GlobalValue::LinkOnceODRLinkage;
652 llvm::Constant *target;
653 if (
auto *func = dyn_cast<llvm::Function>(globalVal)) {
654 target = llvm::DSOLocalEquivalent::get(func);
657 rttiProxyName.append(
".rtti_proxy");
663 llvm::GlobalVariable *proxy = module.getNamedGlobal(rttiProxyName);
665 proxy =
new llvm::GlobalVariable(module, globalVal->getType(),
667 globalVal, rttiProxyName);
668 proxy->setDSOLocal(
true);
669 proxy->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
670 if (!proxy->hasLocalLinkage()) {
671 proxy->setVisibility(llvm::GlobalValue::HiddenVisibility);
672 proxy->setComdat(module.getOrInsertComdat(rttiProxyName));
684 builder.addRelativeOffsetToPosition(CGM.
Int32Ty, target,
693bool CodeGenVTables::useRelativeLayout()
const {
703llvm::Type *CodeGenVTables::getVTableComponentType()
const {
710 builder.add(llvm::ConstantExpr::getIntToPtr(
723 unsigned componentIndex,
724 llvm::Constant *rtti,
725 unsigned &nextVTableThunkIndex,
726 unsigned vtableAddressPoint,
727 bool vtableHasLocalLinkage) {
730 auto addOffsetConstant =
733 switch (component.getKind()) {
735 return addOffsetConstant(CGM, builder, component.getVCallOffset());
738 return addOffsetConstant(CGM, builder, component.getVBaseOffset());
741 return addOffsetConstant(CGM, builder, component.getOffsetToTop());
744 if (useRelativeLayout())
745 return addRelativeComponent(builder, rtti, vtableAddressPoint,
746 vtableHasLocalLinkage,
749 return builder.add(rtti);
765 ? MD->
hasAttr<CUDADeviceAttr>()
766 : (MD->
hasAttr<CUDAHostAttr>() || !MD->
hasAttr<CUDADeviceAttr>());
773 auto getSpecialVirtualFn = [&](StringRef
name) -> llvm::Constant * {
781 if (useRelativeLayout())
789 llvm::FunctionType *fnTy =
790 llvm::FunctionType::get(CGM.
VoidTy,
false);
791 llvm::Constant *fn = cast<llvm::Constant>(
793 if (
auto f = dyn_cast<llvm::Function>(fn))
794 f->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
798 llvm::Constant *fnPtr;
801 if (cast<CXXMethodDecl>(GD.
getDecl())->isPureVirtual()) {
805 fnPtr = PureVirtualFn;
808 }
else if (cast<CXXMethodDecl>(GD.
getDecl())->isDeleted()) {
809 if (!DeletedVirtualFn)
812 fnPtr = DeletedVirtualFn;
815 }
else if (nextVTableThunkIndex < layout.
vtable_thunks().size() &&
818 auto &thunkInfo = layout.
vtable_thunks()[nextVTableThunkIndex].second;
820 nextVTableThunkIndex++;
821 fnPtr = maybeEmitThunk(GD, thunkInfo,
true);
829 if (useRelativeLayout()) {
830 return addRelativeComponent(
831 builder, fnPtr, vtableAddressPoint, vtableHasLocalLinkage,
838 unsigned FnAS = fnPtr->getType()->getPointerAddressSpace();
844 return builder.add(fnPtr);
849 if (useRelativeLayout())
850 return builder.add(llvm::ConstantExpr::getNullValue(CGM.
Int32Ty));
855 llvm_unreachable(
"Unexpected vtable component kind");
860 llvm::Type *componentType = getVTableComponentType();
861 for (
unsigned i = 0, e = layout.
getNumVTables(); i != e; ++i)
862 tys.push_back(llvm::ArrayType::get(componentType, layout.
getVTableSize(i)));
869 llvm::Constant *rtti,
870 bool vtableHasLocalLinkage) {
871 llvm::Type *componentType = getVTableComponentType();
874 unsigned nextVTableThunkIndex = 0;
875 for (
unsigned vtableIndex = 0, endIndex = layout.
getNumVTables();
876 vtableIndex != endIndex; ++vtableIndex) {
877 auto vtableElem = builder.
beginArray(componentType);
880 size_t vtableEnd = vtableStart + layout.
getVTableSize(vtableIndex);
881 for (
size_t componentIndex = vtableStart; componentIndex < vtableEnd;
883 addVTableComponent(vtableElem, layout, componentIndex, rtti,
884 nextVTableThunkIndex, addressPoints[vtableIndex],
885 vtableHasLocalLinkage);
887 vtableElem.finishAndAddTo(builder);
893 llvm::GlobalVariable::LinkageTypes
Linkage,
894 VTableAddressPointsMapTy &AddressPoints) {
896 DI->completeClassData(
Base.getBase());
898 std::unique_ptr<VTableLayout> VTLayout(
900 Base.getBase(),
Base.getBaseOffset(), BaseIsVirtual, RD));
903 AddressPoints = VTLayout->getAddressPoints();
907 llvm::raw_svector_ostream Out(OutName);
909 .mangleCXXCtorVTable(RD,
Base.getBaseOffset().getQuantity(),
910 Base.getBase(), Out);
914 bool VTableAliasExists =
915 UsingRelativeLayout && CGM.
getModule().getNamedAlias(Name);
916 if (VTableAliasExists) {
918 Name.append(
".local");
928 if (
Linkage == llvm::GlobalVariable::AvailableExternallyLinkage)
929 Linkage = llvm::GlobalVariable::InternalLinkage;
931 llvm::Align Align = CGM.
getDataLayout().getABITypeAlign(VTType);
934 llvm::GlobalVariable *VTable =
938 VTable->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
947 VTable->hasLocalLinkage());
948 components.finishAndSetAsInitializer(VTable);
952 assert(!VTable->isDeclaration() &&
"Shouldn't set properties on declaration");
957 if (UsingRelativeLayout) {
959 if (!VTable->isDSOLocal())
976 llvm::GlobalValue::SanitizerMetadata Meta;
977 if (GV->hasSanitizerMetadata())
978 Meta = GV->getSanitizerMetadata();
979 Meta.NoHWAddress =
true;
980 GV->setSanitizerMetadata(Meta);
991 llvm::StringRef AliasNameRef) {
993 "Can only use this if the relative vtable ABI is used");
994 assert(!VTable->isDSOLocal() &&
"This should be called only if the vtable is "
995 "not guaranteed to be dso_local");
1000 if (VTable->hasAvailableExternallyLinkage())
1007 VTable->setName(AliasName +
".local");
1009 auto Linkage = VTable->getLinkage();
1010 assert(llvm::GlobalAlias::isValidLinkage(
Linkage) &&
1011 "Invalid vtable alias linkage");
1013 llvm::GlobalAlias *VTableAlias = CGM.
getModule().getNamedAlias(AliasName);
1015 VTableAlias = llvm::GlobalAlias::create(VTable->getValueType(),
1016 VTable->getAddressSpace(),
Linkage,
1019 assert(VTableAlias->getValueType() == VTable->getValueType());
1020 assert(VTableAlias->getLinkage() ==
Linkage);
1022 VTableAlias->setVisibility(VTable->getVisibility());
1023 VTableAlias->setUnnamedAddr(VTable->getUnnamedAddr());
1026 if (!VTable->hasComdat()) {
1031 VTable->setLinkage(llvm::GlobalValue::PrivateLinkage);
1034 VTable->setVisibility(llvm::GlobalValue::HiddenVisibility);
1037 VTableAlias->setAliasee(VTable);
1049llvm::GlobalVariable::LinkageTypes
1052 return llvm::GlobalVariable::InternalLinkage;
1057 if (keyFunction && !RD->
hasAttr<DLLImportAttr>()) {
1061 if (keyFunction->
hasBody(def))
1062 keyFunction = cast<CXXMethodDecl>(def);
1068 (def || CodeGenOpts.OptimizationLevel > 0 ||
1069 CodeGenOpts.getDebugInfo() != llvm::codegenoptions::NoDebugInfo) &&
1070 "Shouldn't query vtable linkage without key function, "
1071 "optimizations, or debug info");
1072 if (!def && CodeGenOpts.OptimizationLevel > 0)
1073 return llvm::GlobalVariable::AvailableExternallyLinkage;
1077 ? llvm::GlobalVariable::LinkOnceODRLinkage
1078 : llvm::Function::InternalLinkage;
1080 return llvm::GlobalVariable::ExternalLinkage;
1084 llvm::GlobalVariable::LinkOnceODRLinkage :
1085 llvm::Function::InternalLinkage;
1089 llvm::GlobalVariable::WeakODRLinkage :
1090 llvm::Function::InternalLinkage;
1093 llvm_unreachable(
"Should not have been asked to emit this");
1100 return llvm::Function::InternalLinkage;
1102 llvm::GlobalVariable::LinkageTypes DiscardableODRLinkage =
1103 llvm::GlobalValue::LinkOnceODRLinkage;
1104 llvm::GlobalVariable::LinkageTypes NonDiscardableODRLinkage =
1105 llvm::GlobalValue::WeakODRLinkage;
1106 if (RD->
hasAttr<DLLExportAttr>()) {
1108 DiscardableODRLinkage = NonDiscardableODRLinkage;
1109 }
else if (RD->
hasAttr<DLLImportAttr>()) {
1111 DiscardableODRLinkage = llvm::GlobalVariable::AvailableExternallyLinkage;
1112 NonDiscardableODRLinkage = llvm::GlobalVariable::AvailableExternallyLinkage;
1119 return DiscardableODRLinkage;
1125 return DiscardableODRLinkage;
1127 ? llvm::GlobalVariable::AvailableExternallyLinkage
1128 : llvm::GlobalVariable::ExternalLinkage;
1131 return NonDiscardableODRLinkage;
1134 llvm_unreachable(
"Invalid TemplateSpecializationKind!");
1150 DI->completeClassData(RD);
1169 assert(RD->
isDynamicClass() &&
"Non-dynamic classes have no VTable.");
1197 if (!keyFunction->
hasBody(Def))
1200 assert(Def &&
"The body of the key function is not assigned to Def?");
1222void CodeGenModule::EmitDeferredVTables() {
1226 size_t savedSize = DeferredVTables.size();
1232 else if (shouldOpportunisticallyEmitVTables())
1233 OpportunisticVTables.push_back(RD);
1235 assert(savedSize == DeferredVTables.size() &&
1236 "deferred extra vtables during vtable emission?");
1237 DeferredVTables.clear();
1241 if (RD->
hasAttr<LTOVisibilityPublicAttr>() || RD->
hasAttr<UuidAttr>() ||
1250 auto *D = cast<Decl>(DC);
1253 if (
auto *ND = dyn_cast<NamespaceDecl>(D))
1255 if (II->isStr(
"std") || II->isStr(
"stdext"))
1283 if (!
Visited.insert(RD).second)
1284 return llvm::GlobalObject::VCallVisibilityTranslationUnit;
1287 llvm::GlobalObject::VCallVisibility TypeVis;
1289 TypeVis = llvm::GlobalObject::VCallVisibilityTranslationUnit;
1291 TypeVis = llvm::GlobalObject::VCallVisibilityLinkageUnit;
1293 TypeVis = llvm::GlobalObject::VCallVisibilityPublic;
1295 for (
const auto &B : RD->
bases())
1296 if (B.getType()->getAsCXXRecordDecl()->isDynamicClass())
1301 for (
const auto &B : RD->
vbases())
1302 if (B.getType()->getAsCXXRecordDecl()->isDynamicClass())
1311 llvm::GlobalVariable *VTable,
1321 struct AddressPoint {
1325 bool operator<(
const AddressPoint &RHS)
const {
1326 int D =
TypeName.compare(RHS.TypeName);
1327 return D < 0 || (D == 0 && Offset < RHS.Offset);
1330 std::vector<AddressPoint> AddressPoints;
1332 AddressPoint N{AP.first.getBase(),
1334 AP.second.AddressPointIndex,
1336 llvm::raw_string_ostream Stream(N.TypeName);
1338 QualType(N.Base->getTypeForDecl(), 0), Stream);
1339 AddressPoints.push_back(std::move(N));
1343 llvm::sort(AddressPoints);
1346 for (
auto AP : AddressPoints) {
1354 for (
unsigned I = 0; I != Comps.size(); ++I) {
1359 Comps[I].getFunctionDecl()->getType(),
1361 VTable->addTypeMetadata((ComponentWidth * I).getQuantity(), MD);
1368 llvm::GlobalObject::VCallVisibility TypeVis =
1370 if (TypeVis != llvm::GlobalObject::VCallVisibilityPublic)
1371 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.