63#define DEBUG_TYPE "module-summary-analysis"
74 cl::desc(
"Force all edges in the function summary to cold"),
77 "all-non-critical",
"All non-critical edges."),
82 cl::desc(
"File to emit dot graph of new summary into"));
103 bool &RefLocalLinkageIFunc) {
104 bool HasBlockAddress =
false;
106 if (Visited.
insert(CurUser).second)
109 while (!Worklist.
empty()) {
111 const auto *CB = dyn_cast<CallBase>(U);
113 for (
const auto &OI : U->operands()) {
114 const User *Operand = dyn_cast<User>(OI);
117 if (isa<BlockAddress>(Operand)) {
118 HasBlockAddress =
true;
121 if (
auto *GV = dyn_cast<GlobalValue>(Operand)) {
125 if (!(CB && CB->isCallee(&OI))) {
130 if (
auto *GI = dyn_cast_if_present<GlobalIFunc>(GV);
131 GI && GI->hasLocalLinkage()) {
132 RefLocalLinkageIFunc =
true;
135 RefEdges.insert(
Index.getOrInsertValueInfo(GV));
139 if (Visited.
insert(Operand).second)
150 auto ValueDataArray =
152 ActualNumValueData, TotalCount);
154 if (ValueDataArray.get()) {
155 for (
uint32_t j = 0; j < ActualNumValueData; j++) {
156 RefEdges.insert(
Index.getOrInsertValueInfo(
157 ValueDataArray[j].Value));
161 return HasBlockAddress;
167 return CalleeInfo::HotnessType::Unknown;
169 return CalleeInfo::HotnessType::Hot;
171 return CalleeInfo::HotnessType::Cold;
172 return CalleeInfo::HotnessType::None;
186 std::vector<FunctionSummary::ConstVCall>> &ConstVCalls) {
187 std::vector<uint64_t> Args;
189 for (
auto &Arg :
drop_begin(Call.CB.args())) {
190 auto *CI = dyn_cast<ConstantInt>(Arg);
191 if (!CI || CI->getBitWidth() > 64) {
192 VCalls.insert({
Guid, Call.Offset});
195 Args.push_back(CI->getZExtValue());
197 ConstVCalls.insert({{
Guid, Call.Offset}, std::move(Args)});
206 &TypeTestAssumeVCalls,
208 &TypeCheckedLoadVCalls,
210 std::vector<FunctionSummary::ConstVCall>>
211 &TypeTestAssumeConstVCalls,
213 std::vector<FunctionSummary::ConstVCall>>
214 &TypeCheckedLoadConstVCalls,
217 case Intrinsic::type_test:
218 case Intrinsic::public_type_test: {
219 auto *TypeMDVal = cast<MetadataAsValue>(CI->
getArgOperand(1));
220 auto *TypeId = dyn_cast<MDString>(TypeMDVal->getMetadata());
230 return !isa<AssumeInst>(CIU.getUser());
232 if (HasNonAssumeUses)
233 TypeTests.insert(
Guid);
238 for (
auto &Call : DevirtCalls)
240 TypeTestAssumeConstVCalls);
245 case Intrinsic::type_checked_load_relative:
246 case Intrinsic::type_checked_load: {
247 auto *TypeMDVal = cast<MetadataAsValue>(CI->
getArgOperand(2));
248 auto *TypeId = dyn_cast<MDString>(TypeMDVal->getMetadata());
256 bool HasNonCallUses =
false;
258 HasNonCallUses, CI, DT);
262 TypeTests.insert(
Guid);
263 for (
auto &Call : DevirtCalls)
265 TypeCheckedLoadConstVCalls);
275 if (
const auto *LI = dyn_cast<LoadInst>(
I))
276 return !LI->isVolatile();
282 if (
const auto *SI = dyn_cast<StoreInst>(
I))
283 return !SI->isVolatile();
297 return isa<UnreachableInst>(
F.getEntryBlock().getTerminator());
310 unsigned NumInsts = 0;
314 std::vector<std::pair<ValueInfo, CalleeInfo>>>
320 TypeTestAssumeVCalls, TypeCheckedLoadVCalls;
322 std::vector<FunctionSummary::ConstVCall>>
323 TypeTestAssumeConstVCalls, TypeCheckedLoadConstVCalls;
329 bool HasLocalIFuncCallOrRef =
false;
331 std::vector<const Instruction *> NonVolatileLoads;
332 std::vector<const Instruction *> NonVolatileStores;
334 std::vector<CallsiteInfo> Callsites;
335 std::vector<AllocInfo> Allocs;
341 bool HasInlineAsmMaybeReferencingInternal =
false;
342 bool HasIndirBranchToBlockAddress =
false;
343 bool HasUnknownCall =
false;
344 bool MayThrow =
false;
350 if (BB.hasAddressTaken()) {
352 if (!isa<CallBrInst>(*U)) {
353 HasIndirBranchToBlockAddress =
true;
359 if (
I.isDebugOrPseudoInst())
371 NonVolatileLoads.push_back(&
I);
375 NonVolatileStores.push_back(&
I);
382 Value *Stored =
I.getOperand(0);
383 if (
auto *GV = dyn_cast<GlobalValue>(Stored))
387 else if (
auto *U = dyn_cast<User>(Stored))
393 const auto *CB = dyn_cast<CallBase>(&
I);
400 const auto *CI = dyn_cast<CallInst>(&
I);
406 if (HasLocalsInUsedOrAsm && CI && CI->isInlineAsm())
407 HasInlineAsmMaybeReferencingInternal =
true;
409 auto *CalledValue = CB->getCalledOperand();
410 auto *CalledFunction = CB->getCalledFunction();
411 if (CalledValue && !CalledFunction) {
412 CalledValue = CalledValue->stripPointerCasts();
414 CalledFunction = dyn_cast<Function>(CalledValue);
418 if (
auto *GA = dyn_cast<GlobalAlias>(CalledValue)) {
419 assert(!CalledFunction &&
"Expected null called function in callsite for alias");
420 CalledFunction = dyn_cast<Function>(GA->getAliaseeObject());
424 if (CalledFunction) {
425 if (CI && CalledFunction->isIntrinsic()) {
427 CI, TypeTests, TypeTestAssumeVCalls, TypeCheckedLoadVCalls,
428 TypeTestAssumeConstVCalls, TypeCheckedLoadConstVCalls, DT);
432 assert(CalledFunction->hasName());
434 auto Hotness = ScaledCount ?
getHotness(*ScaledCount, PSI)
435 : CalleeInfo::HotnessType::Unknown;
437 Hotness = CalleeInfo::HotnessType::Cold;
444 cast<GlobalValue>(CalledValue))];
446 if (CB->isTailCall())
450 if (BFI !=
nullptr && Hotness == CalleeInfo::HotnessType::Unknown) {
452 uint64_t EntryFreq = BFI->getEntryFreq().getFrequency();
456 HasUnknownCall =
true;
464 if (
auto *GI = dyn_cast_if_present<GlobalIFunc>(CalledValue))
465 if (GI->hasLocalLinkage())
466 HasLocalIFuncCallOrRef =
true;
468 if (CI && CI->isInlineAsm())
471 if (!CalledValue || isa<Constant>(CalledValue))
478 if (
auto *MD =
I.getMetadata(LLVMContext::MD_callees)) {
479 for (
const auto &
Op : MD->operands()) {
480 Function *Callee = mdconst::extract_or_null<Function>(
Op);
482 CallGraphEdges[
Index.getOrInsertValueInfo(Callee)];
488 auto CandidateProfileData =
490 &
I, NumVals, TotalCount, NumCandidates);
491 for (
const auto &Candidate : CandidateProfileData)
492 CallGraphEdges[
Index.getOrInsertValueInfo(Candidate.Value)]
493 .updateHotness(
getHotness(Candidate.Count, PSI));
515 CallsThatMayHaveMemprofSummary.
insert(CB);
521 I.getMetadata(LLVMContext::MD_callsite));
522 auto *MemProfMD =
I.getMetadata(LLVMContext::MD_memprof);
524 std::vector<MIBInfo> MIBs;
525 for (
auto &MDOp : MemProfMD->operands()) {
526 auto *MIBMD = cast<const MDNode>(MDOp);
532 for (
auto ContextIter =
534 ContextIter != StackContext.
end(); ++ContextIter) {
535 unsigned StackIdIdx =
Index.addOrGetStackIdIndex(*ContextIter);
539 if (StackIdIndices.
empty() || StackIdIndices.
back() != StackIdIdx)
545 Allocs.push_back(
AllocInfo(std::move(MIBs)));
546 }
else if (!InstCallsite.
empty()) {
548 for (
auto StackId : InstCallsite)
554 auto CalleeValueInfo =
555 Index.getOrInsertValueInfo(cast<GlobalValue>(CalledValue));
556 Callsites.push_back({CalleeValueInfo, StackIdIndices});
562 Index.addBlockCount(
F.size());
564 std::vector<ValueInfo> Refs;
566 auto AddRefEdges = [&](
const std::vector<const Instruction *> &Instrs,
569 for (
const auto *
I : Instrs) {
578 AddRefEdges(NonVolatileLoads, LoadRefEdges, Visited);
590 AddRefEdges(NonVolatileStores, StoreRefEdges, StoreCache);
595 for (
const auto &VI : StoreRefEdges)
596 if (LoadRefEdges.
remove(VI))
599 unsigned RefCnt = RefEdges.
size();
603 for (
const auto &VI : LoadRefEdges)
606 unsigned FirstWORef = RefEdges.
size();
607 for (
const auto &VI : StoreRefEdges)
611 for (; RefCnt < FirstWORef; ++RefCnt)
612 Refs[RefCnt].setReadOnly();
614 for (; RefCnt < Refs.size(); ++RefCnt)
615 Refs[RefCnt].setWriteOnly();
621 for (
auto &
I :
F.getImportGUIDs())
622 CallGraphEdges[
Index.getOrInsertValueInfo(
I)].updateHotness(
624 ? CalleeInfo::HotnessType::Cold
625 : CalleeInfo::HotnessType::Critical);
634 const auto *CB = dyn_cast<CallBase>(&
I);
638 if (CallsThatMayHaveMemprofSummary.
count(CB))
647 bool NotEligibleForImport =
648 NonRenamableLocal || HasInlineAsmMaybeReferencingInternal ||
649 HasIndirBranchToBlockAddress || HasLocalIFuncCallOrRef;
651 F.getLinkage(),
F.getVisibility(), NotEligibleForImport,
652 false,
F.isDSOLocal(),
F.canBeOmittedFromSymbolTable(),
653 GlobalValueSummary::ImportKind::Definition);
655 F.doesNotAccessMemory(),
F.onlyReadsMemory() && !
F.doesNotAccessMemory(),
656 F.hasFnAttribute(Attribute::NoRecurse),
F.returnDoesNotAlias(),
659 F.getAttributes().hasFnAttr(Attribute::NoInline),
660 F.hasFnAttribute(Attribute::AlwaysInline),
661 F.hasFnAttribute(Attribute::NoUnwind), MayThrow, HasUnknownCall,
663 std::vector<FunctionSummary::ParamAccess> ParamAccesses;
664 if (
auto *SSI = GetSSICallback(
F))
665 ParamAccesses = SSI->getParamAccesses(
Index);
666 auto FuncSummary = std::make_unique<FunctionSummary>(
667 Flags, NumInsts, FunFlags, 0, std::move(Refs),
670 TypeTestAssumeConstVCalls.takeVector(),
671 TypeCheckedLoadConstVCalls.takeVector(), std::move(ParamAccesses),
672 std::move(Callsites), std::move(Allocs));
673 if (NonRenamableLocal)
674 CantBePromoted.
insert(
F.getGUID());
675 Index.addGlobalValueSummary(
F, std::move(FuncSummary));
688 if (
I->getType()->isPointerTy()) {
689 auto C =
I->stripPointerCasts();
690 auto A = dyn_cast<GlobalAlias>(
C);
691 if (isa<Function>(
C) || (
A && isa<Function>(
A->getAliasee()))) {
692 auto GV = dyn_cast<GlobalValue>(
C);
696 if (GV && GV->getName() !=
"__cxa_pure_virtual")
697 VTableFuncs.push_back({
Index.getOrInsertValueInfo(GV), StartingOffset});
705 if (
auto *
C = dyn_cast<ConstantStruct>(
I)) {
706 StructType *STy = dyn_cast<StructType>(
C->getType());
714 StartingOffset +
Offset, M,
Index, VTableFuncs, OrigGV);
716 }
else if (
auto *
C = dyn_cast<ConstantArray>(
I)) {
718 Type *EltTy = ATy->getElementType();
719 uint64_t EltSize =
DL.getTypeAllocSize(EltTy);
720 for (
unsigned i = 0, e = ATy->getNumElements(); i != e; ++i) {
722 StartingOffset + i * EltSize, M,
Index, VTableFuncs,
725 }
else if (
const auto *CE = dyn_cast<ConstantExpr>(
I)) {
727 if (CE->getOpcode() != Instruction::Trunc ||
728 !(CE = dyn_cast<ConstantExpr>(CE->getOperand(0))))
734 if (CE->getOpcode() == Instruction::Sub) {
736 APSInt LHSOffset, RHSOffset;
767 for (
auto &
P : VTableFuncs) {
771 assert(
P.VTableOffset >= PrevOffset);
772 PrevOffset =
P.VTableOffset;
787 cast<ConstantAsMetadata>(
Type->getOperand(0))->getValue())
790 if (
auto *TypeId = dyn_cast<MDString>(
TypeID))
791 Index.getOrInsertTypeIdCompatibleVtableSummary(TypeId->getString())
792 .push_back({
Offset,
Index.getOrInsertValueInfo(&V)});
803 bool RefLocalIFunc =
false;
804 bool HasBlockAddress =
806 const bool NotEligibleForImport = (HasBlockAddress || RefLocalIFunc);
809 V.getLinkage(), V.getVisibility(), NonRenamableLocal,
810 false, V.isDSOLocal(), V.canBeOmittedFromSymbolTable(),
816 if (!
Index.enableSplitLTOUnit()) {
818 V.getMetadata(LLVMContext::MD_type, Types);
819 if (!Types.empty()) {
829 bool CanBeInternalized =
830 !V.hasComdat() && !V.hasAppendingLinkage() && !V.isInterposable() &&
831 !V.hasAvailableExternallyLinkage() && !V.hasDLLExportStorageClass();
834 Constant ?
false : CanBeInternalized,
836 auto GVarSummary = std::make_unique<GlobalVarSummary>(Flags, VarFlags,
838 if (NonRenamableLocal)
839 CantBePromoted.
insert(V.getGUID());
840 if (NotEligibleForImport)
841 GVarSummary->setNotEligibleToImport();
842 if (!VTableFuncs.empty())
843 GVarSummary->setVTableFuncs(VTableFuncs);
844 Index.addGlobalValueSummary(V, std::move(GVarSummary));
852 if (isa<GlobalIFunc>(Aliasee))
856 A.getLinkage(),
A.getVisibility(), NonRenamableLocal,
857 false,
A.isDSOLocal(),
A.canBeOmittedFromSymbolTable(),
859 auto AS = std::make_unique<AliasSummary>(Flags);
860 auto AliaseeVI =
Index.getValueInfo(Aliasee->
getGUID());
861 assert(AliaseeVI &&
"Alias expects aliasee summary to be available");
862 assert(AliaseeVI.getSummaryList().size() == 1 &&
863 "Expected a single entry per aliasee in per-module index");
864 AS->setAliasee(AliaseeVI, AliaseeVI.getSummaryList()[0].get());
865 if (NonRenamableLocal)
866 CantBePromoted.
insert(
A.getGUID());
867 Index.addGlobalValueSummary(
A, std::move(AS));
873 for (
const auto &Summary : VI.getSummaryList())
874 Summary->setLive(
true);
883 bool EnableSplitLTOUnit =
false;
884 bool UnifiedLTO =
false;
885 if (
auto *MD = mdconst::extract_or_null<ConstantInt>(
886 M.getModuleFlag(
"EnableSplitLTOUnit")))
887 EnableSplitLTOUnit = MD->getZExtValue();
889 mdconst::extract_or_null<ConstantInt>(M.getModuleFlag(
"UnifiedLTO")))
890 UnifiedLTO = MD->getZExtValue();
905 for (
auto *V : Used) {
906 if (V->hasLocalLinkage()) {
908 CantBePromoted.
insert(V->getGUID());
912 bool HasLocalInlineAsmSymbol =
false;
913 if (!M.getModuleInlineAsm().empty()) {
929 HasLocalInlineAsmSymbol =
true;
942 if (
Function *
F = dyn_cast<Function>(GV)) {
943 std::unique_ptr<FunctionSummary> Summary =
944 std::make_unique<FunctionSummary>(
947 F->hasFnAttribute(Attribute::ReadNone),
948 F->hasFnAttribute(Attribute::ReadOnly),
949 F->hasFnAttribute(Attribute::NoRecurse),
950 F->returnDoesNotAlias(),
952 F->hasFnAttribute(Attribute::AlwaysInline),
953 F->hasFnAttribute(Attribute::NoUnwind),
966 Index.addGlobalValueSummary(*GV, std::move(Summary));
968 std::unique_ptr<GlobalVarSummary> Summary =
969 std::make_unique<GlobalVarSummary>(
972 false,
false, cast<GlobalVariable>(GV)->
isConstant(),
975 Index.addGlobalValueSummary(*GV, std::move(Summary));
980 bool IsThinLTO =
true;
982 mdconst::extract_or_null<ConstantInt>(M.getModuleFlag(
"ThinLTO")))
983 IsThinLTO = MD->getZExtValue();
987 for (
const auto &
F : M) {
988 if (
F.isDeclaration())
993 std::unique_ptr<BlockFrequencyInfo> BFIPtr;
995 BFI = GetBFICallback(
F);
996 else if (
F.hasProfileData()) {
999 BFIPtr = std::make_unique<BlockFrequencyInfo>(
F, BPI, LI);
1004 !LocalsUsed.
empty() || HasLocalInlineAsmSymbol,
1005 CantBePromoted, IsThinLTO, GetSSICallback);
1012 if (
G.isDeclaration())
1025 Index.getGlobalValueSummary(GV)->setLive(
true);
1029 for (
auto *V : LocalsUsed) {
1030 auto *Summary =
Index.getGlobalValueSummary(*V);
1031 assert(Summary &&
"Missing summary for global value");
1032 Summary->setNotEligibleToImport();
1044 for (
auto &GlobalList :
Index) {
1046 if (GlobalList.second.SummaryList.empty())
1049 assert(GlobalList.second.SummaryList.size() == 1 &&
1050 "Expected module's index to have one summary per GUID");
1051 auto &Summary = GlobalList.second.SummaryList[0];
1053 Summary->setNotEligibleToImport();
1057 bool AllRefsCanBeExternallyReferenced =
1059 return !CantBePromoted.count(VI.getGUID());
1061 if (!AllRefsCanBeExternallyReferenced) {
1062 Summary->setNotEligibleToImport();
1066 if (
auto *FuncSummary = dyn_cast<FunctionSummary>(Summary.get())) {
1069 return !CantBePromoted.count(Edge.first.getGUID());
1071 if (!AllCallsCanBeExternallyReferenced)
1072 Summary->setNotEligibleToImport();
1082 Index.exportToDot(OSDot, {});
1112 "Module Summary Analysis",
false,
true)
1129 auto *PSI = &getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI();
1134 return &(this->getAnalysis<BlockFrequencyInfoWrapperPass>(
1140 return NeedSSI ? &getAnalysis<StackSafetyInfoWrapperPass>(
1180 "Module summary info",
false,
true)
1185 if (CB->isDebugOrPseudoInst())
1187 auto *CI = dyn_cast<CallInst>(CB);
1188 auto *CalledValue = CB->getCalledOperand();
1189 auto *CalledFunction = CB->getCalledFunction();
1190 if (CalledValue && !CalledFunction) {
1191 CalledValue = CalledValue->stripPointerCasts();
1193 CalledFunction = dyn_cast<Function>(CalledValue);
1197 if (
auto *GA = dyn_cast<GlobalAlias>(CalledValue)) {
1198 assert(!CalledFunction &&
1199 "Expected null called function in callsite for alias");
1200 CalledFunction = dyn_cast<Function>(GA->getAliaseeObject());
1204 if (CalledFunction) {
1205 if (CI && CalledFunction->isIntrinsic())
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static bool isConstant(const MachineInstr &MI)
This file contains the simple types necessary to represent the attributes associated with functions a...
block Block Frequency Analysis
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
This file contains the declarations for the subclasses of Constant, which represent the different fla...
This file defines the DenseSet and SmallDenseSet classes.
This file implements a map that provides insertion order iteration.
static void addVCallToSet(DevirtCallSite Call, GlobalValue::GUID Guid, SetVector< FunctionSummary::VFuncId, std::vector< FunctionSummary::VFuncId > > &VCalls, SetVector< FunctionSummary::ConstVCall, std::vector< FunctionSummary::ConstVCall > > &ConstVCalls)
Determine whether this call has all constant integer arguments (excluding "this") and summarize it to...
cl::opt< unsigned > MaxNumVTableAnnotations
static void computeVTableFuncs(ModuleSummaryIndex &Index, const GlobalVariable &V, const Module &M, VTableFuncList &VTableFuncs)
static void computeAliasSummary(ModuleSummaryIndex &Index, const GlobalAlias &A, DenseSet< GlobalValue::GUID > &CantBePromoted)
static void findFuncPointers(const Constant *I, uint64_t StartingOffset, const Module &M, ModuleSummaryIndex &Index, VTableFuncList &VTableFuncs, const GlobalVariable &OrigGV)
Find function pointers referenced within the given vtable initializer (or subset of an initializer) I...
static void computeVariableSummary(ModuleSummaryIndex &Index, const GlobalVariable &V, DenseSet< GlobalValue::GUID > &CantBePromoted, const Module &M, SmallVectorImpl< MDNode * > &Types)
static void setLiveRoot(ModuleSummaryIndex &Index, StringRef Name)
static CalleeInfo::HotnessType getHotness(uint64_t ProfileCount, ProfileSummaryInfo *PSI)
static bool isNonVolatileLoad(const Instruction *I)
cl::opt< bool > ScalePartialSampleProfileWorkingSetSize
static bool isNonRenamableLocal(const GlobalValue &GV)
static void computeFunctionSummary(ModuleSummaryIndex &Index, const Module &M, const Function &F, BlockFrequencyInfo *BFI, ProfileSummaryInfo *PSI, DominatorTree &DT, bool HasLocalsInUsedOrAsm, DenseSet< GlobalValue::GUID > &CantBePromoted, bool IsThinLTO, std::function< const StackSafetyInfo *(const Function &F)> GetSSICallback)
static bool findRefEdges(ModuleSummaryIndex &Index, const User *CurUser, SetVector< ValueInfo, std::vector< ValueInfo > > &RefEdges, SmallPtrSet< const User *, 8 > &Visited, bool &RefLocalLinkageIFunc)
static cl::opt< FunctionSummary::ForceSummaryHotnessType, true > FSEC("force-summary-edges-cold", cl::Hidden, cl::location(ForceSummaryEdgesCold), cl::desc("Force all edges in the function summary to cold"), cl::values(clEnumValN(FunctionSummary::FSHT_None, "none", "None."), clEnumValN(FunctionSummary::FSHT_AllNonCritical, "all-non-critical", "All non-critical edges."), clEnumValN(FunctionSummary::FSHT_All, "all", "All edges.")))
static bool mustBeUnreachableFunction(const Function &F)
static bool isNonVolatileStore(const Instruction *I)
static cl::opt< std::string > ModuleSummaryDotFile("module-summary-dot-file", cl::Hidden, cl::value_desc("filename"), cl::desc("File to emit dot graph of new summary into"))
static void addIntrinsicToSummary(const CallInst *CI, SetVector< GlobalValue::GUID, std::vector< GlobalValue::GUID > > &TypeTests, SetVector< FunctionSummary::VFuncId, std::vector< FunctionSummary::VFuncId > > &TypeTestAssumeVCalls, SetVector< FunctionSummary::VFuncId, std::vector< FunctionSummary::VFuncId > > &TypeCheckedLoadVCalls, SetVector< FunctionSummary::ConstVCall, std::vector< FunctionSummary::ConstVCall > > &TypeTestAssumeConstVCalls, SetVector< FunctionSummary::ConstVCall, std::vector< FunctionSummary::ConstVCall > > &TypeCheckedLoadConstVCalls, DominatorTree &DT)
If this intrinsic call requires that we add information to the function summary, do so via the non-co...
static void recordTypeIdCompatibleVtableReferences(ModuleSummaryIndex &Index, const GlobalVariable &V, SmallVectorImpl< MDNode * > &Types)
Record vtable definition V for each type metadata it references.
This is the interface to build a ModuleSummaryIndex for a module.
ModuleSummaryIndex.h This file contains the declarations the classes that hold the module index and s...
Module.h This file contains the declarations for the Module class.
FunctionAnalysisManager FAM
#define INITIALIZE_PASS_DEPENDENCY(depName)
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file implements a set that has insertion order iteration characteristics.
This file defines the SmallPtrSet class.
This file defines the SmallVector class.
This defines the Use class.
An arbitrary precision integer that knows its signedness.
A container for analyses that lazily runs them and caches their results.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
void setPreservesAll()
Set by analyses that do not transform their input at all.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
LLVM Basic Block Representation.
static BlockAddress * get(Function *F, BasicBlock *BB)
Return a BlockAddress for the specified function and basic block.
Analysis pass which computes BlockFrequencyInfo.
Legacy analysis pass which computes BlockFrequencyInfo.
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
Analysis providing branch probability information.
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation or the function signa...
Value * getArgOperand(unsigned i) const
This class represents a function call, abstracting a target machine's calling convention.
This is an important base class in LLVM.
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
Implements a dense probed hash-table based set.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
std::pair< ValueInfo, CalleeInfo > EdgeTy
<CalleeValueInfo, CalleeInfo> call edge pair.
ForceSummaryHotnessType
Types for -force-summary-edges-cold debugging option.
Class to represent profile counts.
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
bool hasLocalLinkage() const
static GUID getGUID(StringRef GlobalName)
Return a 64-bit global unique ID constructed from global value name (i.e.
GUID getGUID() const
Return a 64-bit global unique ID constructed from global value name (i.e.
@ DefaultVisibility
The GV is visible.
bool canBeOmittedFromSymbolTable() const
True if GV can be left out of the object symbol table.
@ InternalLinkage
Rename collisions when linking (static functions).
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
Legacy wrapper pass to provide the ModuleSummaryIndex object.
ImmutableModuleSummaryIndexWrapperPass(const ModuleSummaryIndex *Index=nullptr)
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
ImmutablePass class - This class is used to provide information that does not need to be run.
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
This class implements a map that also provides access to all stored values in a deterministic order.
VectorType takeVector()
Clear the MapVector and return the underlying vector.
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Result run(Module &M, ModuleAnalysisManager &AM)
Legacy wrapper pass to provide the ModuleSummaryIndex object.
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
bool doFinalization(Module &M) override
doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes...
ModuleSummaryIndexWrapperPass()
bool runOnModule(Module &M) override
runOnModule - Virtual method overriden by subclasses to process the module being operated on.
Class to hold module path string table and global value map, and encapsulate methods for operating on...
static void CollectAsmSymbols(const Module &M, function_ref< void(StringRef, object::BasicSymbolRef::Flags)> AsmSymbol)
Parse inline ASM and collect the symbols that are defined or referenced in the current module.
A Module instance is used to store all the information related to an LLVM module.
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
An analysis pass based on the new PM to deliver ProfileSummaryInfo.
An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo.
Analysis providing profile information.
std::optional< uint64_t > getProfileCount(const CallBase &CallInst, BlockFrequencyInfo *BFI, bool AllowSynthetic=false) const
Returns the profile count for CallInst.
bool isColdCount(uint64_t C) const
Returns true if count C is considered cold.
bool hasPartialSampleProfile() const
Returns true if module M has partial-profile sample profile.
bool isHotCount(uint64_t C) const
Returns true if count C is considered hot.
A vector that has set insertion semantics.
bool remove(const value_type &X)
Remove an item from the set vector.
size_type size() const
Determine the number of elements in the SetVector.
Vector takeVector()
Clear the SetVector and return the underlying vector.
bool insert(const value_type &X)
Insert a new element into the SetVector.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StackSafetyInfo wrapper for the new pass manager.
StackSafetyInfo wrapper for the legacy pass manager.
Interface to access stack safety analysis results for single function.
StringRef - Represent a constant reference to a string, i.e.
Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...
unsigned getElementContainingOffset(uint64_t FixedOffset) const
Given a valid byte offset into the structure, returns the structure index that contains it.
TypeSize getElementOffset(unsigned Idx) const
Class to represent struct types.
ArrayRef< Type * > elements() const
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
The instances of the Type class are immutable: once they are created, they are never changed.
TypeID
Definitions of all of the base types for the Type system.
A Use represents the edge between a Value definition and its users.
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
iterator_range< use_iterator > uses()
std::pair< iterator, bool > insert(const ValueT &V)
size_type count(const_arg_type_t< ValueT > V) const
Return 1 if the specified key is in the set, 0 otherwise.
Helper class to iterate through stack ids in both metadata (memprof MIB and callsite) and the corresp...
CallStackIterator end() const
CallStackIterator beginAfterSharedPrefix(CallStack &Other)
A raw_ostream that writes to a file descriptor.
@ C
The default llvm calling convention, compatible with C.
ValuesClass values(OptsTy... Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
LocationClass< Ty > location(Ty &L)
AllocationType getMIBAllocType(const MDNode *MIB)
Returns the allocation type from an MIB metadata node.
MDNode * getMIBStackNode(const MDNode *MIB)
Returns the stack node from an MIB metadata node.
This is an optimization pass for GlobalISel generic memory operations.
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
bool getValueProfDataFromInst(const Instruction &Inst, InstrProfValueKind ValueKind, uint32_t MaxNumValueData, InstrProfValueData ValueData[], uint32_t &ActualNumValueData, uint64_t &TotalC, bool GetNoICPValue=false)
Extract the value profile data from Inst which is annotated with value profile meta data.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
auto enumerate(FirstRange &&First, RestRanges &&...Rest)
Given two or more input ranges, returns a new range whose values are are tuples (A,...
bool IsConstantOffsetFromGlobal(Constant *C, GlobalValue *&GV, APInt &Offset, const DataLayout &DL, DSOLocalEquivalent **DSOEquiv=nullptr)
If this constant is a constant offset from a global, return the global and the constant.
FunctionSummary::ForceSummaryHotnessType ForceSummaryEdgesCold
bool needsParamAccessSummary(const Module &M)
ModuleSummaryIndex buildModuleSummaryIndex(const Module &M, std::function< BlockFrequencyInfo *(const Function &F)> GetBFICallback, ProfileSummaryInfo *PSI, std::function< const StackSafetyInfo *(const Function &F)> GetSSICallback=[](const Function &F) -> const StackSafetyInfo *{ return nullptr;})
Direct function to compute a ModuleSummaryIndex from a given module.
void initializeModuleSummaryIndexWrapperPassPass(PassRegistry &)
std::vector< VirtFuncOffset > VTableFuncList
List of functions referenced by a particular vtable definition.
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
void findDevirtualizableCallsForTypeCheckedLoad(SmallVectorImpl< DevirtCallSite > &DevirtCalls, SmallVectorImpl< Instruction * > &LoadedPtrs, SmallVectorImpl< Instruction * > &Preds, bool &HasNonCallUses, const CallInst *CI, DominatorTree &DT)
Given a call to the intrinsic @llvm.type.checked.load, find all devirtualizable call sites based on t...
ModulePass * createModuleSummaryIndexWrapperPass()
ImmutablePass * createImmutableModuleSummaryIndexWrapperPass(const ModuleSummaryIndex *Index)
void initializeImmutableModuleSummaryIndexWrapperPassPass(PassRegistry &)
bool mayHaveMemprofSummary(const CallBase *CB)
Returns true if the instruction could have memprof metadata, used to ensure consistency between summa...
void findDevirtualizableCallsForTypeTest(SmallVectorImpl< DevirtCallSite > &DevirtCalls, SmallVectorImpl< CallInst * > &Assumes, const CallInst *CI, DominatorTree &DT)
Given a call to the intrinsic @llvm.type.test, find all devirtualizable call sites based on the call ...
GlobalVariable * collectUsedGlobalVariables(const Module &M, SmallVectorImpl< GlobalValue * > &Vec, bool CompilerUsed)
Given "llvm.used" or "llvm.compiler.used" as a global name, collect the initializer elements of that ...
Summary of memprof metadata on allocations.
A special type used by analysis passes to provide an address that identifies that particular analysis...
A call site that could be devirtualized.
A specification for a virtual function call with all constant integer arguments.
Flags specific to function summaries.
An "identifier" for a virtual function.
Group flags (Linkage, NotEligibleToImport, etc.) as a bitfield.
Summary of a single MIB in a memprof metadata on allocations.
Struct that holds a reference to a particular GUID in a global value summary.