62#define DEBUG_TYPE "module-summary-analysis"
73 cl::desc(
"Force all edges in the function summary to cold"),
76 "all-non-critical",
"All non-critical edges."),
81 cl::desc(
"File to emit dot graph of new summary into"));
98 bool HasBlockAddress =
false;
100 if (Visited.
insert(CurUser).second)
103 while (!Worklist.
empty()) {
105 const auto *CB = dyn_cast<CallBase>(U);
107 for (
const auto &OI : U->operands()) {
108 const User *Operand = dyn_cast<User>(OI);
111 if (isa<BlockAddress>(Operand)) {
112 HasBlockAddress =
true;
115 if (
auto *GV = dyn_cast<GlobalValue>(Operand)) {
119 if (!(CB && CB->isCallee(&OI)))
120 RefEdges.insert(
Index.getOrInsertValueInfo(GV));
123 if (Visited.
insert(Operand).second)
127 return HasBlockAddress;
133 return CalleeInfo::HotnessType::Unknown;
135 return CalleeInfo::HotnessType::Hot;
137 return CalleeInfo::HotnessType::Cold;
138 return CalleeInfo::HotnessType::None;
152 std::vector<FunctionSummary::ConstVCall>> &ConstVCalls) {
153 std::vector<uint64_t> Args;
155 for (
auto &Arg :
drop_begin(Call.CB.args())) {
156 auto *CI = dyn_cast<ConstantInt>(Arg);
157 if (!CI || CI->getBitWidth() > 64) {
158 VCalls.insert({Guid, Call.Offset});
161 Args.push_back(CI->getZExtValue());
163 ConstVCalls.insert({{Guid, Call.Offset}, std::move(Args)});
172 &TypeTestAssumeVCalls,
174 &TypeCheckedLoadVCalls,
176 std::vector<FunctionSummary::ConstVCall>>
177 &TypeTestAssumeConstVCalls,
179 std::vector<FunctionSummary::ConstVCall>>
180 &TypeCheckedLoadConstVCalls,
183 case Intrinsic::type_test:
184 case Intrinsic::public_type_test: {
185 auto *TypeMDVal = cast<MetadataAsValue>(CI->
getArgOperand(1));
186 auto *TypeId = dyn_cast<MDString>(TypeMDVal->getMetadata());
196 return !isa<AssumeInst>(CIU.getUser());
198 if (HasNonAssumeUses)
199 TypeTests.insert(Guid);
204 for (
auto &Call : DevirtCalls)
206 TypeTestAssumeConstVCalls);
211 case Intrinsic::type_checked_load_relative:
212 case Intrinsic::type_checked_load: {
213 auto *TypeMDVal = cast<MetadataAsValue>(CI->
getArgOperand(2));
214 auto *TypeId = dyn_cast<MDString>(TypeMDVal->getMetadata());
222 bool HasNonCallUses =
false;
224 HasNonCallUses, CI, DT);
228 TypeTests.insert(Guid);
229 for (
auto &Call : DevirtCalls)
231 TypeCheckedLoadConstVCalls);
241 if (
const auto *LI = dyn_cast<LoadInst>(
I))
242 return !LI->isVolatile();
248 if (
const auto *SI = dyn_cast<StoreInst>(
I))
249 return !SI->isVolatile();
263 return isa<UnreachableInst>(
F.getEntryBlock().getTerminator());
276 unsigned NumInsts = 0;
280 std::vector<std::pair<ValueInfo, CalleeInfo>>>
286 TypeTestAssumeVCalls, TypeCheckedLoadVCalls;
288 std::vector<FunctionSummary::ConstVCall>>
289 TypeTestAssumeConstVCalls, TypeCheckedLoadConstVCalls;
296 std::vector<const Instruction *> NonVolatileLoads;
297 std::vector<const Instruction *> NonVolatileStores;
299 std::vector<CallsiteInfo> Callsites;
300 std::vector<AllocInfo> Allocs;
306 bool HasInlineAsmMaybeReferencingInternal =
false;
307 bool HasIndirBranchToBlockAddress =
false;
308 bool HasIFuncCall =
false;
309 bool HasUnknownCall =
false;
310 bool MayThrow =
false;
316 if (BB.hasAddressTaken()) {
318 if (!isa<CallBrInst>(*U)) {
319 HasIndirBranchToBlockAddress =
true;
325 if (
I.isDebugOrPseudoInst())
337 NonVolatileLoads.push_back(&
I);
341 NonVolatileStores.push_back(&
I);
348 Value *Stored =
I.getOperand(0);
349 if (
auto *GV = dyn_cast<GlobalValue>(Stored))
353 else if (
auto *U = dyn_cast<User>(Stored))
359 const auto *CB = dyn_cast<CallBase>(&
I);
366 const auto *CI = dyn_cast<CallInst>(&
I);
372 if (HasLocalsInUsedOrAsm && CI && CI->isInlineAsm())
373 HasInlineAsmMaybeReferencingInternal =
true;
375 auto *CalledValue = CB->getCalledOperand();
376 auto *CalledFunction = CB->getCalledFunction();
377 if (CalledValue && !CalledFunction) {
378 CalledValue = CalledValue->stripPointerCasts();
380 CalledFunction = dyn_cast<Function>(CalledValue);
384 if (
auto *GA = dyn_cast<GlobalAlias>(CalledValue)) {
385 assert(!CalledFunction &&
"Expected null called function in callsite for alias");
386 CalledFunction = dyn_cast<Function>(GA->getAliaseeObject());
390 if (CalledFunction) {
391 if (CI && CalledFunction->isIntrinsic()) {
393 CI, TypeTests, TypeTestAssumeVCalls, TypeCheckedLoadVCalls,
394 TypeTestAssumeConstVCalls, TypeCheckedLoadConstVCalls, DT);
398 assert(CalledFunction->hasName());
400 auto Hotness = ScaledCount ?
getHotness(*ScaledCount, PSI)
401 : CalleeInfo::HotnessType::Unknown;
403 Hotness = CalleeInfo::HotnessType::Cold;
410 cast<GlobalValue>(CalledValue))];
414 if (BFI !=
nullptr && Hotness == CalleeInfo::HotnessType::Unknown) {
415 uint64_t BBFreq = BFI->getBlockFreq(&BB).getFrequency();
416 uint64_t EntryFreq = BFI->getEntryFreq();
417 ValueInfo.updateRelBlockFreq(BBFreq, EntryFreq);
420 HasUnknownCall =
true;
428 if (
auto *GI = dyn_cast_if_present<GlobalIFunc>(CalledValue))
429 if (GI->hasLocalLinkage())
432 if (CI && CI->isInlineAsm())
435 if (!CalledValue || isa<Constant>(CalledValue))
442 if (
auto *MD =
I.getMetadata(LLVMContext::MD_callees)) {
443 for (
const auto &
Op : MD->operands()) {
444 Function *Callee = mdconst::extract_or_null<Function>(
Op);
446 CallGraphEdges[
Index.getOrInsertValueInfo(Callee)];
452 auto CandidateProfileData =
454 &
I, NumVals, TotalCount, NumCandidates);
455 for (
const auto &Candidate : CandidateProfileData)
456 CallGraphEdges[
Index.getOrInsertValueInfo(Candidate.Value)]
457 .updateHotness(
getHotness(Candidate.Count, PSI));
479 CallsThatMayHaveMemprofSummary.
insert(CB);
485 I.getMetadata(LLVMContext::MD_callsite));
486 auto *MemProfMD =
I.getMetadata(LLVMContext::MD_memprof);
488 std::vector<MIBInfo> MIBs;
489 for (
auto &MDOp : MemProfMD->operands()) {
490 auto *MIBMD = cast<const MDNode>(MDOp);
496 for (
auto ContextIter =
498 ContextIter != StackContext.
end(); ++ContextIter) {
499 unsigned StackIdIdx =
Index.addOrGetStackIdIndex(*ContextIter);
503 if (StackIdIndices.
empty() || StackIdIndices.
back() != StackIdIdx)
509 Allocs.push_back(
AllocInfo(std::move(MIBs)));
510 }
else if (!InstCallsite.
empty()) {
512 for (
auto StackId : InstCallsite)
518 auto CalleeValueInfo =
519 Index.getOrInsertValueInfo(cast<GlobalValue>(CalledValue));
520 Callsites.push_back({CalleeValueInfo, StackIdIndices});
526 Index.addBlockCount(
F.size());
528 std::vector<ValueInfo> Refs;
530 auto AddRefEdges = [&](
const std::vector<const Instruction *> &Instrs,
533 for (
const auto *
I : Instrs) {
542 AddRefEdges(NonVolatileLoads, LoadRefEdges, Visited);
554 AddRefEdges(NonVolatileStores, StoreRefEdges, StoreCache);
559 for (
const auto &VI : StoreRefEdges)
560 if (LoadRefEdges.
remove(VI))
563 unsigned RefCnt = RefEdges.
size();
567 for (
const auto &VI : LoadRefEdges)
570 unsigned FirstWORef = RefEdges.
size();
571 for (
const auto &VI : StoreRefEdges)
575 for (; RefCnt < FirstWORef; ++RefCnt)
576 Refs[RefCnt].setReadOnly();
578 for (; RefCnt < Refs.size(); ++RefCnt)
579 Refs[RefCnt].setWriteOnly();
585 for (
auto &
I :
F.getImportGUIDs())
586 CallGraphEdges[
Index.getOrInsertValueInfo(
I)].updateHotness(
588 ? CalleeInfo::HotnessType::Cold
589 : CalleeInfo::HotnessType::Critical);
598 const auto *CB = dyn_cast<CallBase>(&
I);
602 if (CallsThatMayHaveMemprofSummary.
count(CB))
611 bool NotEligibleForImport = NonRenamableLocal ||
612 HasInlineAsmMaybeReferencingInternal ||
613 HasIndirBranchToBlockAddress || HasIFuncCall;
615 F.getLinkage(),
F.getVisibility(), NotEligibleForImport,
616 false,
F.isDSOLocal(),
F.canBeOmittedFromSymbolTable());
618 F.doesNotAccessMemory(),
F.onlyReadsMemory() && !
F.doesNotAccessMemory(),
619 F.hasFnAttribute(Attribute::NoRecurse),
F.returnDoesNotAlias(),
622 F.getAttributes().hasFnAttr(Attribute::NoInline),
623 F.hasFnAttribute(Attribute::AlwaysInline),
624 F.hasFnAttribute(Attribute::NoUnwind), MayThrow, HasUnknownCall,
626 std::vector<FunctionSummary::ParamAccess> ParamAccesses;
627 if (
auto *SSI = GetSSICallback(
F))
628 ParamAccesses = SSI->getParamAccesses(
Index);
629 auto FuncSummary = std::make_unique<FunctionSummary>(
630 Flags, NumInsts, FunFlags, 0, std::move(Refs),
633 TypeTestAssumeConstVCalls.takeVector(),
634 TypeCheckedLoadConstVCalls.takeVector(), std::move(ParamAccesses),
635 std::move(Callsites), std::move(Allocs));
636 if (NonRenamableLocal)
637 CantBePromoted.
insert(
F.getGUID());
638 Index.addGlobalValueSummary(
F, std::move(FuncSummary));
650 if (
I->getType()->isPointerTy()) {
651 auto C =
I->stripPointerCasts();
652 auto A = dyn_cast<GlobalAlias>(
C);
653 if (isa<Function>(
C) || (
A && isa<Function>(
A->getAliasee()))) {
654 auto GV = dyn_cast<GlobalValue>(
C);
658 if (GV && GV->getName() !=
"__cxa_pure_virtual")
659 VTableFuncs.push_back({
Index.getOrInsertValueInfo(GV), StartingOffset});
667 if (
auto *
C = dyn_cast<ConstantStruct>(
I)) {
668 StructType *STy = dyn_cast<StructType>(
C->getType());
678 }
else if (
auto *
C = dyn_cast<ConstantArray>(
I)) {
680 Type *EltTy = ATy->getElementType();
681 uint64_t EltSize =
DL.getTypeAllocSize(EltTy);
682 for (
unsigned i = 0, e = ATy->getNumElements(); i != e; ++i) {
684 StartingOffset + i * EltSize, M,
Index, VTableFuncs);
702 for (
auto &
P : VTableFuncs) {
706 assert(
P.VTableOffset >= PrevOffset);
707 PrevOffset =
P.VTableOffset;
722 cast<ConstantAsMetadata>(
Type->getOperand(0))->getValue())
725 if (
auto *TypeId = dyn_cast<MDString>(
TypeID))
726 Index.getOrInsertTypeIdCompatibleVtableSummary(TypeId->getString())
727 .push_back({
Offset,
Index.getOrInsertValueInfo(&V)});
741 V.getLinkage(), V.getVisibility(), NonRenamableLocal,
742 false, V.isDSOLocal(), V.canBeOmittedFromSymbolTable());
747 if (!
Index.enableSplitLTOUnit()) {
749 V.getMetadata(LLVMContext::MD_type, Types);
750 if (!Types.empty()) {
760 bool CanBeInternalized =
761 !V.hasComdat() && !V.hasAppendingLinkage() && !V.isInterposable() &&
762 !V.hasAvailableExternallyLinkage() && !V.hasDLLExportStorageClass();
765 Constant ?
false : CanBeInternalized,
767 auto GVarSummary = std::make_unique<GlobalVarSummary>(Flags, VarFlags,
769 if (NonRenamableLocal)
770 CantBePromoted.
insert(V.getGUID());
772 GVarSummary->setNotEligibleToImport();
773 if (!VTableFuncs.empty())
774 GVarSummary->setVTableFuncs(VTableFuncs);
775 Index.addGlobalValueSummary(V, std::move(GVarSummary));
783 if (isa<GlobalIFunc>(Aliasee))
787 A.getLinkage(),
A.getVisibility(), NonRenamableLocal,
788 false,
A.isDSOLocal(),
A.canBeOmittedFromSymbolTable());
789 auto AS = std::make_unique<AliasSummary>(Flags);
790 auto AliaseeVI =
Index.getValueInfo(Aliasee->
getGUID());
791 assert(AliaseeVI &&
"Alias expects aliasee summary to be available");
792 assert(AliaseeVI.getSummaryList().size() == 1 &&
793 "Expected a single entry per aliasee in per-module index");
794 AS->setAliasee(AliaseeVI, AliaseeVI.getSummaryList()[0].get());
795 if (NonRenamableLocal)
796 CantBePromoted.
insert(
A.getGUID());
797 Index.addGlobalValueSummary(
A, std::move(AS));
803 for (
const auto &Summary : VI.getSummaryList())
804 Summary->setLive(
true);
813 bool EnableSplitLTOUnit =
false;
814 bool UnifiedLTO =
false;
815 if (
auto *MD = mdconst::extract_or_null<ConstantInt>(
816 M.getModuleFlag(
"EnableSplitLTOUnit")))
817 EnableSplitLTOUnit = MD->getZExtValue();
819 mdconst::extract_or_null<ConstantInt>(M.getModuleFlag(
"UnifiedLTO")))
820 UnifiedLTO = MD->getZExtValue();
835 for (
auto *V : Used) {
836 if (V->hasLocalLinkage()) {
838 CantBePromoted.
insert(V->getGUID());
842 bool HasLocalInlineAsmSymbol =
false;
843 if (!M.getModuleInlineAsm().empty()) {
859 HasLocalInlineAsmSymbol =
true;
871 if (
Function *
F = dyn_cast<Function>(GV)) {
872 std::unique_ptr<FunctionSummary> Summary =
873 std::make_unique<FunctionSummary>(
876 F->hasFnAttribute(Attribute::ReadNone),
877 F->hasFnAttribute(Attribute::ReadOnly),
878 F->hasFnAttribute(Attribute::NoRecurse),
879 F->returnDoesNotAlias(),
881 F->hasFnAttribute(Attribute::AlwaysInline),
882 F->hasFnAttribute(Attribute::NoUnwind),
895 Index.addGlobalValueSummary(*GV, std::move(Summary));
897 std::unique_ptr<GlobalVarSummary> Summary =
898 std::make_unique<GlobalVarSummary>(
901 false,
false, cast<GlobalVariable>(GV)->
isConstant(),
904 Index.addGlobalValueSummary(*GV, std::move(Summary));
909 bool IsThinLTO =
true;
911 mdconst::extract_or_null<ConstantInt>(M.getModuleFlag(
"ThinLTO")))
912 IsThinLTO = MD->getZExtValue();
916 for (
const auto &
F : M) {
917 if (
F.isDeclaration())
922 std::unique_ptr<BlockFrequencyInfo> BFIPtr;
924 BFI = GetBFICallback(
F);
925 else if (
F.hasProfileData()) {
928 BFIPtr = std::make_unique<BlockFrequencyInfo>(
F, BPI, LI);
933 !LocalsUsed.
empty() || HasLocalInlineAsmSymbol,
934 CantBePromoted, IsThinLTO, GetSSICallback);
941 if (
G.isDeclaration())
954 Index.getGlobalValueSummary(GV)->setLive(
true);
958 for (
auto *V : LocalsUsed) {
959 auto *Summary =
Index.getGlobalValueSummary(*V);
960 assert(Summary &&
"Missing summary for global value");
961 Summary->setNotEligibleToImport();
973 for (
auto &GlobalList :
Index) {
975 if (GlobalList.second.SummaryList.empty())
978 assert(GlobalList.second.SummaryList.size() == 1 &&
979 "Expected module's index to have one summary per GUID");
980 auto &Summary = GlobalList.second.SummaryList[0];
982 Summary->setNotEligibleToImport();
986 bool AllRefsCanBeExternallyReferenced =
988 return !CantBePromoted.count(VI.getGUID());
990 if (!AllRefsCanBeExternallyReferenced) {
991 Summary->setNotEligibleToImport();
995 if (
auto *FuncSummary = dyn_cast<FunctionSummary>(Summary.get())) {
998 return !CantBePromoted.count(Edge.first.getGUID());
1000 if (!AllCallsCanBeExternallyReferenced)
1001 Summary->setNotEligibleToImport();
1011 Index.exportToDot(OSDot, {});
1041 "Module Summary Analysis",
false,
true)
1058 auto *PSI = &getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI();
1063 return &(this->getAnalysis<BlockFrequencyInfoWrapperPass>(
1069 return NeedSSI ? &getAnalysis<StackSafetyInfoWrapperPass>(
1109 "Module summary info",
false,
true)
1114 if (CB->isDebugOrPseudoInst())
1116 auto *CI = dyn_cast<CallInst>(CB);
1117 auto *CalledValue = CB->getCalledOperand();
1118 auto *CalledFunction = CB->getCalledFunction();
1119 if (CalledValue && !CalledFunction) {
1120 CalledValue = CalledValue->stripPointerCasts();
1122 CalledFunction = dyn_cast<Function>(CalledValue);
1126 if (
auto *GA = dyn_cast<GlobalAlias>(CalledValue)) {
1127 assert(!CalledFunction &&
1128 "Expected null called function in callsite for alias");
1129 CalledFunction = dyn_cast<Function>(GA->getAliaseeObject());
1133 if (CalledFunction) {
1134 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...
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 bool findRefEdges(ModuleSummaryIndex &Index, const User *CurUser, SetVector< ValueInfo, std::vector< ValueInfo > > &RefEdges, SmallPtrSet< const User *, 8 > &Visited)
static void findFuncPointers(const Constant *I, uint64_t StartingOffset, const Module &M, ModuleSummaryIndex &Index, VTableFuncList &VTableFuncs)
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 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.
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
GUID getGUID() const
Return a 64-bit global unique ID constructed from global value name (i.e.
@ DefaultVisibility
The GV is visible.
static GUID getGUID(StringRef GlobalName)
Return a 64-bit global unique ID constructed from global value name (i.e.
bool canBeOmittedFromSymbolTable() const
True if GV can be left out of the object symbol table.
@ InternalLinkage
Rename collisions when linking (static functions).
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.
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 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,...
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.