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"));
97 bool HasBlockAddress =
false;
99 if (Visited.
insert(CurUser).second)
102 while (!Worklist.
empty()) {
104 const auto *CB = dyn_cast<CallBase>(U);
106 for (
const auto &OI : U->operands()) {
107 const User *Operand = dyn_cast<User>(OI);
110 if (isa<BlockAddress>(Operand)) {
111 HasBlockAddress =
true;
114 if (
auto *GV = dyn_cast<GlobalValue>(Operand)) {
118 if (!(CB && CB->isCallee(&OI)))
122 if (Visited.
insert(Operand).second)
126 return HasBlockAddress;
132 return CalleeInfo::HotnessType::Unknown;
134 return CalleeInfo::HotnessType::Hot;
136 return CalleeInfo::HotnessType::Cold;
137 return CalleeInfo::HotnessType::None;
149 std::vector<uint64_t> Args;
152 auto *CI = dyn_cast<ConstantInt>(
Arg);
153 if (!CI || CI->getBitWidth() > 64) {
154 VCalls.
insert({Guid, Call.Offset});
157 Args.push_back(CI->getZExtValue());
159 ConstVCalls.
insert({{Guid, Call.Offset}, std::move(Args)});
172 case Intrinsic::type_test:
173 case Intrinsic::public_type_test: {
174 auto *TypeMDVal = cast<MetadataAsValue>(CI->
getArgOperand(1));
175 auto *TypeId = dyn_cast<MDString>(TypeMDVal->getMetadata());
185 return !isa<AssumeInst>(CIU.getUser());
187 if (HasNonAssumeUses)
193 for (
auto &Call : DevirtCalls)
195 TypeTestAssumeConstVCalls);
200 case Intrinsic::type_checked_load: {
201 auto *TypeMDVal = cast<MetadataAsValue>(CI->
getArgOperand(2));
202 auto *TypeId = dyn_cast<MDString>(TypeMDVal->getMetadata());
210 bool HasNonCallUses =
false;
212 HasNonCallUses, CI, DT);
217 for (
auto &Call : DevirtCalls)
219 TypeCheckedLoadConstVCalls);
229 if (
const auto *LI = dyn_cast<LoadInst>(
I))
230 return !LI->isVolatile();
236 if (
const auto *
SI = dyn_cast<StoreInst>(
I))
237 return !
SI->isVolatile();
251 return isa<UnreachableInst>(
F.getEntryBlock().getTerminator());
264 unsigned NumInsts = 0;
271 TypeCheckedLoadVCalls;
273 TypeCheckedLoadConstVCalls;
280 std::vector<const Instruction *> NonVolatileLoads;
281 std::vector<const Instruction *> NonVolatileStores;
283 std::vector<CallsiteInfo> Callsites;
284 std::vector<AllocInfo> Allocs;
286 bool HasInlineAsmMaybeReferencingInternal =
false;
287 bool HasIndirBranchToBlockAddress =
false;
288 bool HasUnknownCall =
false;
289 bool MayThrow =
false;
295 if (BB.hasAddressTaken()) {
297 if (!isa<CallBrInst>(*U)) {
298 HasIndirBranchToBlockAddress =
true;
304 if (
I.isDebugOrPseudoInst())
316 NonVolatileLoads.push_back(&
I);
320 NonVolatileStores.push_back(&
I);
327 Value *Stored =
I.getOperand(0);
328 if (
auto *GV = dyn_cast<GlobalValue>(Stored))
332 else if (
auto *U = dyn_cast<User>(Stored))
338 const auto *CB = dyn_cast<CallBase>(&
I);
345 const auto *CI = dyn_cast<CallInst>(&
I);
351 if (HasLocalsInUsedOrAsm && CI && CI->isInlineAsm())
352 HasInlineAsmMaybeReferencingInternal =
true;
354 auto *CalledValue = CB->getCalledOperand();
355 auto *CalledFunction = CB->getCalledFunction();
356 if (CalledValue && !CalledFunction) {
357 CalledValue = CalledValue->stripPointerCasts();
359 CalledFunction = dyn_cast<Function>(CalledValue);
363 if (
auto *GA = dyn_cast<GlobalAlias>(CalledValue)) {
364 assert(!CalledFunction &&
"Expected null called function in callsite for alias");
365 CalledFunction = dyn_cast<Function>(GA->getAliaseeObject());
369 if (CalledFunction) {
370 if (CI && CalledFunction->isIntrinsic()) {
372 CI, TypeTests, TypeTestAssumeVCalls, TypeCheckedLoadVCalls,
373 TypeTestAssumeConstVCalls, TypeCheckedLoadConstVCalls, DT);
377 assert(CalledFunction->hasName());
379 auto Hotness = ScaledCount ?
getHotness(*ScaledCount, PSI)
380 : CalleeInfo::HotnessType::Unknown;
382 Hotness = CalleeInfo::HotnessType::Cold;
389 cast<GlobalValue>(CalledValue))];
393 if (BFI !=
nullptr && Hotness == CalleeInfo::HotnessType::Unknown) {
394 uint64_t BBFreq = BFI->getBlockFreq(&BB).getFrequency();
395 uint64_t EntryFreq = BFI->getEntryFreq();
396 ValueInfo.updateRelBlockFreq(BBFreq, EntryFreq);
399 HasUnknownCall =
true;
401 if (CI && CI->isInlineAsm())
404 if (!CalledValue || isa<Constant>(CalledValue))
411 if (
auto *MD =
I.getMetadata(LLVMContext::MD_callees)) {
412 for (
const auto &Op : MD->operands()) {
415 CallGraphEdges[
Index.getOrInsertValueInfo(
Callee)];
421 auto CandidateProfileData =
423 &
I, NumVals, TotalCount, NumCandidates);
424 for (
const auto &Candidate : CandidateProfileData)
425 CallGraphEdges[
Index.getOrInsertValueInfo(Candidate.Value)]
426 .updateHotness(
getHotness(Candidate.Count, PSI));
442 I.getMetadata(LLVMContext::MD_callsite));
443 auto *MemProfMD =
I.getMetadata(LLVMContext::MD_memprof);
445 std::vector<MIBInfo> MIBs;
446 for (
auto &MDOp : MemProfMD->operands()) {
447 auto *MIBMD = cast<const MDNode>(MDOp);
453 for (
auto ContextIter =
455 ContextIter != StackContext.
end(); ++ContextIter) {
456 unsigned StackIdIdx =
Index.addOrGetStackIdIndex(*ContextIter);
460 if (StackIdIndices.
empty() || StackIdIndices.
back() != StackIdIdx)
466 Allocs.push_back(
AllocInfo(std::move(MIBs)));
467 }
else if (!InstCallsite.
empty()) {
469 for (
auto StackId : InstCallsite)
475 auto CalleeValueInfo =
476 Index.getOrInsertValueInfo(cast<GlobalValue>(CalledValue));
477 Callsites.push_back({CalleeValueInfo, StackIdIndices});
481 Index.addBlockCount(
F.size());
483 std::vector<ValueInfo> Refs;
485 auto AddRefEdges = [&](
const std::vector<const Instruction *> &Instrs,
488 for (
const auto *
I : Instrs) {
497 AddRefEdges(NonVolatileLoads, LoadRefEdges, Visited);
509 AddRefEdges(NonVolatileStores, StoreRefEdges, StoreCache);
514 for (
const auto &
VI : StoreRefEdges)
518 unsigned RefCnt = RefEdges.
size();
522 for (
const auto &
VI : LoadRefEdges)
525 unsigned FirstWORef = RefEdges.
size();
526 for (
const auto &
VI : StoreRefEdges)
530 for (; RefCnt < FirstWORef; ++RefCnt)
531 Refs[RefCnt].setReadOnly();
533 for (; RefCnt < Refs.size(); ++RefCnt)
534 Refs[RefCnt].setWriteOnly();
540 for (
auto &
I :
F.getImportGUIDs())
541 CallGraphEdges[
Index.getOrInsertValueInfo(
I)].updateHotness(
543 ? CalleeInfo::HotnessType::Cold
544 : CalleeInfo::HotnessType::Critical);
547 bool NotEligibleForImport = NonRenamableLocal ||
548 HasInlineAsmMaybeReferencingInternal ||
549 HasIndirBranchToBlockAddress;
551 F.getLinkage(),
F.getVisibility(), NotEligibleForImport,
552 false,
F.isDSOLocal(),
F.canBeOmittedFromSymbolTable());
554 F.doesNotAccessMemory(),
F.onlyReadsMemory() && !
F.doesNotAccessMemory(),
555 F.hasFnAttribute(Attribute::NoRecurse),
F.returnDoesNotAlias(),
558 F.getAttributes().hasFnAttr(Attribute::NoInline),
559 F.hasFnAttribute(Attribute::AlwaysInline),
560 F.hasFnAttribute(Attribute::NoUnwind), MayThrow, HasUnknownCall,
562 std::vector<FunctionSummary::ParamAccess> ParamAccesses;
563 if (
auto *SSI = GetSSICallback(
F))
564 ParamAccesses = SSI->getParamAccesses(
Index);
565 auto FuncSummary = std::make_unique<FunctionSummary>(
566 Flags, NumInsts, FunFlags, 0, std::move(Refs),
570 TypeCheckedLoadConstVCalls.
takeVector(), std::move(ParamAccesses),
571 std::move(Callsites), std::move(Allocs));
572 if (NonRenamableLocal)
573 CantBePromoted.
insert(
F.getGUID());
574 Index.addGlobalValueSummary(
F, std::move(FuncSummary));
587 if (
I->getType()->isPointerTy()) {
588 auto C =
I->stripPointerCasts();
589 auto A = dyn_cast<GlobalAlias>(
C);
590 if (isa<Function>(
C) || (
A && isa<Function>(
A->getAliasee()))) {
591 auto GV = dyn_cast<GlobalValue>(
C);
595 if (GV && GV->getName() !=
"__cxa_pure_virtual")
596 VTableFuncs.push_back({
Index.getOrInsertValueInfo(GV), StartingOffset});
604 if (
auto *
C = dyn_cast<ConstantStruct>(
I)) {
605 StructType *STy = dyn_cast<StructType>(
C->getType());
613 StartingOffset +
Offset, M,
Index, VTableFuncs, OrigGV);
615 }
else if (
auto *
C = dyn_cast<ConstantArray>(
I)) {
617 Type *EltTy = ATy->getElementType();
618 uint64_t EltSize =
DL.getTypeAllocSize(EltTy);
619 for (
unsigned i = 0, e = ATy->getNumElements(); i != e; ++i) {
621 StartingOffset + i * EltSize, M,
Index, VTableFuncs,
624 }
else if (
const auto *CE = dyn_cast<ConstantExpr>(
I)) {
626 if (CE->getOpcode() != Instruction::Trunc ||
627 !(CE = dyn_cast<ConstantExpr>(CE->getOperand(0))))
633 if (CE->getOpcode() == Instruction::Sub) {
635 APSInt LHSOffset, RHSOffset;
666 for (
auto &
P : VTableFuncs) {
670 assert(
P.VTableOffset >= PrevOffset);
671 PrevOffset =
P.VTableOffset;
686 cast<ConstantAsMetadata>(
Type->getOperand(0))->getValue())
689 if (
auto *TypeId = dyn_cast<MDString>(
TypeID))
690 Index.getOrInsertTypeIdCompatibleVtableSummary(TypeId->getString())
691 .push_back({
Offset,
Index.getOrInsertValueInfo(&V)});
705 V.getLinkage(), V.getVisibility(), NonRenamableLocal,
706 false, V.isDSOLocal(), V.canBeOmittedFromSymbolTable());
711 if (!
Index.enableSplitLTOUnit()) {
713 V.getMetadata(LLVMContext::MD_type, Types);
714 if (!Types.empty()) {
724 bool CanBeInternalized =
725 !V.hasComdat() && !V.hasAppendingLinkage() && !V.isInterposable() &&
726 !V.hasAvailableExternallyLinkage() && !V.hasDLLExportStorageClass();
729 Constant ?
false : CanBeInternalized,
731 auto GVarSummary = std::make_unique<GlobalVarSummary>(
Flags, VarFlags,
733 if (NonRenamableLocal)
734 CantBePromoted.
insert(V.getGUID());
736 GVarSummary->setNotEligibleToImport();
737 if (!VTableFuncs.empty())
738 GVarSummary->setVTableFuncs(VTableFuncs);
739 Index.addGlobalValueSummary(V, std::move(GVarSummary));
747 if (isa<GlobalIFunc>(Aliasee))
751 A.getLinkage(),
A.getVisibility(), NonRenamableLocal,
752 false,
A.isDSOLocal(),
A.canBeOmittedFromSymbolTable());
753 auto AS = std::make_unique<AliasSummary>(
Flags);
754 auto AliaseeVI =
Index.getValueInfo(Aliasee->
getGUID());
755 assert(AliaseeVI &&
"Alias expects aliasee summary to be available");
756 assert(AliaseeVI.getSummaryList().size() == 1 &&
757 "Expected a single entry per aliasee in per-module index");
758 AS->setAliasee(AliaseeVI, AliaseeVI.getSummaryList()[0].get());
759 if (NonRenamableLocal)
760 CantBePromoted.
insert(
A.getGUID());
761 Index.addGlobalValueSummary(
A, std::move(AS));
767 for (
const auto &Summary :
VI.getSummaryList())
768 Summary->setLive(
true);
777 bool EnableSplitLTOUnit =
false;
778 if (
auto *MD = mdconst::extract_or_null<ConstantInt>(
779 M.getModuleFlag(
"EnableSplitLTOUnit")))
780 EnableSplitLTOUnit = MD->getZExtValue();
795 for (
auto *V : Used) {
796 if (V->hasLocalLinkage()) {
798 CantBePromoted.
insert(V->getGUID());
802 bool HasLocalInlineAsmSymbol =
false;
803 if (!M.getModuleInlineAsm().empty()) {
819 HasLocalInlineAsmSymbol =
true;
831 if (
Function *
F = dyn_cast<Function>(GV)) {
832 std::unique_ptr<FunctionSummary> Summary =
833 std::make_unique<FunctionSummary>(
836 F->hasFnAttribute(Attribute::ReadNone),
837 F->hasFnAttribute(Attribute::ReadOnly),
838 F->hasFnAttribute(Attribute::NoRecurse),
839 F->returnDoesNotAlias(),
841 F->hasFnAttribute(Attribute::AlwaysInline),
842 F->hasFnAttribute(Attribute::NoUnwind),
855 Index.addGlobalValueSummary(*GV, std::move(Summary));
857 std::unique_ptr<GlobalVarSummary> Summary =
858 std::make_unique<GlobalVarSummary>(
861 false,
false, cast<GlobalVariable>(GV)->
isConstant(),
864 Index.addGlobalValueSummary(*GV, std::move(Summary));
869 bool IsThinLTO =
true;
871 mdconst::extract_or_null<ConstantInt>(M.getModuleFlag(
"ThinLTO")))
872 IsThinLTO = MD->getZExtValue();
876 for (
const auto &
F : M) {
877 if (
F.isDeclaration())
882 std::unique_ptr<BlockFrequencyInfo> BFIPtr;
884 BFI = GetBFICallback(
F);
885 else if (
F.hasProfileData()) {
888 BFIPtr = std::make_unique<BlockFrequencyInfo>(
F, BPI, LI);
893 !LocalsUsed.
empty() || HasLocalInlineAsmSymbol,
894 CantBePromoted, IsThinLTO, GetSSICallback);
901 if (
G.isDeclaration())
914 Index.getGlobalValueSummary(GV)->setLive(
true);
918 for (
auto *V : LocalsUsed) {
919 auto *Summary =
Index.getGlobalValueSummary(*V);
920 assert(Summary &&
"Missing summary for global value");
921 Summary->setNotEligibleToImport();
933 for (
auto &GlobalList :
Index) {
935 if (GlobalList.second.SummaryList.empty())
938 assert(GlobalList.second.SummaryList.size() == 1 &&
939 "Expected module's index to have one summary per GUID");
940 auto &Summary = GlobalList.second.SummaryList[0];
942 Summary->setNotEligibleToImport();
946 bool AllRefsCanBeExternallyReferenced =
948 return !CantBePromoted.count(VI.getGUID());
950 if (!AllRefsCanBeExternallyReferenced) {
951 Summary->setNotEligibleToImport();
955 if (
auto *FuncSummary = dyn_cast<FunctionSummary>(Summary.get())) {
958 return !CantBePromoted.count(Edge.first.getGUID());
960 if (!AllCallsCanBeExternallyReferenced)
961 Summary->setNotEligibleToImport();
971 Index.exportToDot(OSDot, {});
1001 "Module Summary Analysis",
false,
true)
1018 auto *PSI = &getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI();
1023 return &(this->getAnalysis<BlockFrequencyInfoWrapperPass>(
1029 return NeedSSI ? &getAnalysis<StackSafetyInfoWrapperPass>(
1069 "Module summary info",
false,
true)
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static bool isConstant(const MachineInstr &MI)
amdgpu Simplify well known AMD library false FunctionCallee Callee
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
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...
demanded Demanded bits analysis
This file defines the DenseSet and SmallDenseSet classes.
This file implements a map that provides insertion order iteration.
static bool findRefEdges(ModuleSummaryIndex &Index, const User *CurUser, SetVector< ValueInfo > &RefEdges, SmallPtrSet< const User *, 8 > &Visited)
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)
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 void addIntrinsicToSummary(const CallInst *CI, SetVector< GlobalValue::GUID > &TypeTests, SetVector< FunctionSummary::VFuncId > &TypeTestAssumeVCalls, SetVector< FunctionSummary::VFuncId > &TypeCheckedLoadVCalls, SetVector< FunctionSummary::ConstVCall > &TypeTestAssumeConstVCalls, SetVector< 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 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 addVCallToSet(DevirtCallSite Call, GlobalValue::GUID Guid, SetVector< FunctionSummary::VFuncId > &VCalls, SetVector< FunctionSummary::ConstVCall > &ConstVCalls)
Determine whether this call has all constant integer arguments (excluding "this") and summarize it to...
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.
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.
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).
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 isHotCount(uint64_t C) const
Returns true if count C is considered hot.
A vector that has set insertion semantics.
size_type size() const
Determine the number of elements in the SetVector.
bool remove(const value_type &X)
Remove an item from the set vector.
bool insert(const value_type &X)
Insert a new element into the SetVector.
Vector takeVector()
Clear the SetVector and return the underlying vector.
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...
uint64_t getElementOffset(unsigned Idx) const
unsigned getElementContainingOffset(uint64_t Offset) const
Given a valid byte offset into the structure, returns the structure index that contains it.
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)
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,...
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 &)
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.
Flags specific to function summaries.
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.