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"));
101 bool HasBlockAddress =
false;
103 if (Visited.
insert(CurUser).second)
106 while (!Worklist.
empty()) {
108 const auto *CB = dyn_cast<CallBase>(U);
110 for (
const auto &OI : U->operands()) {
111 const User *Operand = dyn_cast<User>(OI);
114 if (isa<BlockAddress>(Operand)) {
115 HasBlockAddress =
true;
118 if (
auto *GV = dyn_cast<GlobalValue>(Operand)) {
122 if (!(CB && CB->isCallee(&OI)))
123 RefEdges.insert(
Index.getOrInsertValueInfo(GV));
126 if (Visited.
insert(Operand).second)
137 auto ValueDataArray =
139 ActualNumValueData, TotalCount);
141 if (ValueDataArray.get()) {
142 for (
uint32_t j = 0; j < ActualNumValueData; j++) {
143 RefEdges.insert(
Index.getOrInsertValueInfo(
144 ValueDataArray[j].Value));
148 return HasBlockAddress;
154 return CalleeInfo::HotnessType::Unknown;
156 return CalleeInfo::HotnessType::Hot;
158 return CalleeInfo::HotnessType::Cold;
159 return CalleeInfo::HotnessType::None;
173 std::vector<FunctionSummary::ConstVCall>> &ConstVCalls) {
174 std::vector<uint64_t> Args;
176 for (
auto &Arg :
drop_begin(Call.CB.args())) {
177 auto *CI = dyn_cast<ConstantInt>(Arg);
178 if (!CI || CI->getBitWidth() > 64) {
179 VCalls.insert({Guid, Call.Offset});
182 Args.push_back(CI->getZExtValue());
184 ConstVCalls.insert({{Guid, Call.Offset}, std::move(Args)});
193 &TypeTestAssumeVCalls,
195 &TypeCheckedLoadVCalls,
197 std::vector<FunctionSummary::ConstVCall>>
198 &TypeTestAssumeConstVCalls,
200 std::vector<FunctionSummary::ConstVCall>>
201 &TypeCheckedLoadConstVCalls,
204 case Intrinsic::type_test:
205 case Intrinsic::public_type_test: {
206 auto *TypeMDVal = cast<MetadataAsValue>(CI->
getArgOperand(1));
207 auto *TypeId = dyn_cast<MDString>(TypeMDVal->getMetadata());
217 return !isa<AssumeInst>(CIU.getUser());
219 if (HasNonAssumeUses)
220 TypeTests.insert(Guid);
225 for (
auto &Call : DevirtCalls)
227 TypeTestAssumeConstVCalls);
232 case Intrinsic::type_checked_load_relative:
233 case Intrinsic::type_checked_load: {
234 auto *TypeMDVal = cast<MetadataAsValue>(CI->
getArgOperand(2));
235 auto *TypeId = dyn_cast<MDString>(TypeMDVal->getMetadata());
243 bool HasNonCallUses =
false;
245 HasNonCallUses, CI, DT);
249 TypeTests.insert(Guid);
250 for (
auto &Call : DevirtCalls)
252 TypeCheckedLoadConstVCalls);
262 if (
const auto *LI = dyn_cast<LoadInst>(
I))
263 return !LI->isVolatile();
269 if (
const auto *SI = dyn_cast<StoreInst>(
I))
270 return !SI->isVolatile();
284 return isa<UnreachableInst>(
F.getEntryBlock().getTerminator());
297 unsigned NumInsts = 0;
301 std::vector<std::pair<ValueInfo, CalleeInfo>>>
307 TypeTestAssumeVCalls, TypeCheckedLoadVCalls;
309 std::vector<FunctionSummary::ConstVCall>>
310 TypeTestAssumeConstVCalls, TypeCheckedLoadConstVCalls;
317 std::vector<const Instruction *> NonVolatileLoads;
318 std::vector<const Instruction *> NonVolatileStores;
320 std::vector<CallsiteInfo> Callsites;
321 std::vector<AllocInfo> Allocs;
327 bool HasInlineAsmMaybeReferencingInternal =
false;
328 bool HasIndirBranchToBlockAddress =
false;
329 bool HasIFuncCall =
false;
330 bool HasUnknownCall =
false;
331 bool MayThrow =
false;
337 if (BB.hasAddressTaken()) {
339 if (!isa<CallBrInst>(*U)) {
340 HasIndirBranchToBlockAddress =
true;
346 if (
I.isDebugOrPseudoInst())
358 NonVolatileLoads.push_back(&
I);
362 NonVolatileStores.push_back(&
I);
369 Value *Stored =
I.getOperand(0);
370 if (
auto *GV = dyn_cast<GlobalValue>(Stored))
374 else if (
auto *U = dyn_cast<User>(Stored))
380 const auto *CB = dyn_cast<CallBase>(&
I);
387 const auto *CI = dyn_cast<CallInst>(&
I);
393 if (HasLocalsInUsedOrAsm && CI && CI->isInlineAsm())
394 HasInlineAsmMaybeReferencingInternal =
true;
396 auto *CalledValue = CB->getCalledOperand();
397 auto *CalledFunction = CB->getCalledFunction();
398 if (CalledValue && !CalledFunction) {
399 CalledValue = CalledValue->stripPointerCasts();
401 CalledFunction = dyn_cast<Function>(CalledValue);
405 if (
auto *GA = dyn_cast<GlobalAlias>(CalledValue)) {
406 assert(!CalledFunction &&
"Expected null called function in callsite for alias");
407 CalledFunction = dyn_cast<Function>(GA->getAliaseeObject());
411 if (CalledFunction) {
412 if (CI && CalledFunction->isIntrinsic()) {
414 CI, TypeTests, TypeTestAssumeVCalls, TypeCheckedLoadVCalls,
415 TypeTestAssumeConstVCalls, TypeCheckedLoadConstVCalls, DT);
419 assert(CalledFunction->hasName());
421 auto Hotness = ScaledCount ?
getHotness(*ScaledCount, PSI)
422 : CalleeInfo::HotnessType::Unknown;
424 Hotness = CalleeInfo::HotnessType::Cold;
431 cast<GlobalValue>(CalledValue))];
433 if (CB->isTailCall())
437 if (BFI !=
nullptr && Hotness == CalleeInfo::HotnessType::Unknown) {
439 uint64_t EntryFreq = BFI->getEntryFreq().getFrequency();
443 HasUnknownCall =
true;
451 if (
auto *GI = dyn_cast_if_present<GlobalIFunc>(CalledValue))
452 if (GI->hasLocalLinkage())
455 if (CI && CI->isInlineAsm())
458 if (!CalledValue || isa<Constant>(CalledValue))
465 if (
auto *MD =
I.getMetadata(LLVMContext::MD_callees)) {
466 for (
const auto &
Op : MD->operands()) {
467 Function *Callee = mdconst::extract_or_null<Function>(
Op);
469 CallGraphEdges[
Index.getOrInsertValueInfo(Callee)];
475 auto CandidateProfileData =
477 &
I, NumVals, TotalCount, NumCandidates);
478 for (
const auto &Candidate : CandidateProfileData)
479 CallGraphEdges[
Index.getOrInsertValueInfo(Candidate.Value)]
480 .updateHotness(
getHotness(Candidate.Count, PSI));
502 CallsThatMayHaveMemprofSummary.
insert(CB);
508 I.getMetadata(LLVMContext::MD_callsite));
509 auto *MemProfMD =
I.getMetadata(LLVMContext::MD_memprof);
511 std::vector<MIBInfo> MIBs;
512 for (
auto &MDOp : MemProfMD->operands()) {
513 auto *MIBMD = cast<const MDNode>(MDOp);
519 for (
auto ContextIter =
521 ContextIter != StackContext.
end(); ++ContextIter) {
522 unsigned StackIdIdx =
Index.addOrGetStackIdIndex(*ContextIter);
526 if (StackIdIndices.
empty() || StackIdIndices.
back() != StackIdIdx)
532 Allocs.push_back(
AllocInfo(std::move(MIBs)));
533 }
else if (!InstCallsite.
empty()) {
535 for (
auto StackId : InstCallsite)
541 auto CalleeValueInfo =
542 Index.getOrInsertValueInfo(cast<GlobalValue>(CalledValue));
543 Callsites.push_back({CalleeValueInfo, StackIdIndices});
549 Index.addBlockCount(
F.size());
551 std::vector<ValueInfo> Refs;
553 auto AddRefEdges = [&](
const std::vector<const Instruction *> &Instrs,
556 for (
const auto *
I : Instrs) {
565 AddRefEdges(NonVolatileLoads, LoadRefEdges, Visited);
577 AddRefEdges(NonVolatileStores, StoreRefEdges, StoreCache);
582 for (
const auto &VI : StoreRefEdges)
583 if (LoadRefEdges.
remove(VI))
586 unsigned RefCnt = RefEdges.
size();
590 for (
const auto &VI : LoadRefEdges)
593 unsigned FirstWORef = RefEdges.
size();
594 for (
const auto &VI : StoreRefEdges)
598 for (; RefCnt < FirstWORef; ++RefCnt)
599 Refs[RefCnt].setReadOnly();
601 for (; RefCnt < Refs.size(); ++RefCnt)
602 Refs[RefCnt].setWriteOnly();
608 for (
auto &
I :
F.getImportGUIDs())
609 CallGraphEdges[
Index.getOrInsertValueInfo(
I)].updateHotness(
611 ? CalleeInfo::HotnessType::Cold
612 : CalleeInfo::HotnessType::Critical);
621 const auto *CB = dyn_cast<CallBase>(&
I);
625 if (CallsThatMayHaveMemprofSummary.
count(CB))
634 bool NotEligibleForImport = NonRenamableLocal ||
635 HasInlineAsmMaybeReferencingInternal ||
636 HasIndirBranchToBlockAddress || HasIFuncCall;
638 F.getLinkage(),
F.getVisibility(), NotEligibleForImport,
639 false,
F.isDSOLocal(),
F.canBeOmittedFromSymbolTable(),
640 GlobalValueSummary::ImportKind::Definition);
642 F.doesNotAccessMemory(),
F.onlyReadsMemory() && !
F.doesNotAccessMemory(),
643 F.hasFnAttribute(Attribute::NoRecurse),
F.returnDoesNotAlias(),
646 F.getAttributes().hasFnAttr(Attribute::NoInline),
647 F.hasFnAttribute(Attribute::AlwaysInline),
648 F.hasFnAttribute(Attribute::NoUnwind), MayThrow, HasUnknownCall,
650 std::vector<FunctionSummary::ParamAccess> ParamAccesses;
651 if (
auto *SSI = GetSSICallback(
F))
652 ParamAccesses = SSI->getParamAccesses(
Index);
653 auto FuncSummary = std::make_unique<FunctionSummary>(
654 Flags, NumInsts, FunFlags, 0, std::move(Refs),
657 TypeTestAssumeConstVCalls.takeVector(),
658 TypeCheckedLoadConstVCalls.takeVector(), std::move(ParamAccesses),
659 std::move(Callsites), std::move(Allocs));
660 if (NonRenamableLocal)
661 CantBePromoted.
insert(
F.getGUID());
662 Index.addGlobalValueSummary(
F, std::move(FuncSummary));
675 if (
I->getType()->isPointerTy()) {
676 auto C =
I->stripPointerCasts();
677 auto A = dyn_cast<GlobalAlias>(
C);
678 if (isa<Function>(
C) || (
A && isa<Function>(
A->getAliasee()))) {
679 auto GV = dyn_cast<GlobalValue>(
C);
683 if (GV && GV->getName() !=
"__cxa_pure_virtual")
684 VTableFuncs.push_back({
Index.getOrInsertValueInfo(GV), StartingOffset});
692 if (
auto *
C = dyn_cast<ConstantStruct>(
I)) {
693 StructType *STy = dyn_cast<StructType>(
C->getType());
701 StartingOffset +
Offset, M,
Index, VTableFuncs, OrigGV);
703 }
else if (
auto *
C = dyn_cast<ConstantArray>(
I)) {
705 Type *EltTy = ATy->getElementType();
706 uint64_t EltSize =
DL.getTypeAllocSize(EltTy);
707 for (
unsigned i = 0, e = ATy->getNumElements(); i != e; ++i) {
709 StartingOffset + i * EltSize, M,
Index, VTableFuncs,
712 }
else if (
const auto *CE = dyn_cast<ConstantExpr>(
I)) {
714 if (CE->getOpcode() != Instruction::Trunc ||
715 !(CE = dyn_cast<ConstantExpr>(CE->getOperand(0))))
721 if (CE->getOpcode() == Instruction::Sub) {
723 APSInt LHSOffset, RHSOffset;
754 for (
auto &
P : VTableFuncs) {
758 assert(
P.VTableOffset >= PrevOffset);
759 PrevOffset =
P.VTableOffset;
774 cast<ConstantAsMetadata>(
Type->getOperand(0))->getValue())
777 if (
auto *TypeId = dyn_cast<MDString>(
TypeID))
778 Index.getOrInsertTypeIdCompatibleVtableSummary(TypeId->getString())
779 .push_back({
Offset,
Index.getOrInsertValueInfo(&V)});
793 V.getLinkage(), V.getVisibility(), NonRenamableLocal,
794 false, V.isDSOLocal(), V.canBeOmittedFromSymbolTable(),
800 if (!
Index.enableSplitLTOUnit()) {
802 V.getMetadata(LLVMContext::MD_type, Types);
803 if (!Types.empty()) {
813 bool CanBeInternalized =
814 !V.hasComdat() && !V.hasAppendingLinkage() && !V.isInterposable() &&
815 !V.hasAvailableExternallyLinkage() && !V.hasDLLExportStorageClass();
818 Constant ?
false : CanBeInternalized,
820 auto GVarSummary = std::make_unique<GlobalVarSummary>(Flags, VarFlags,
822 if (NonRenamableLocal)
823 CantBePromoted.
insert(V.getGUID());
825 GVarSummary->setNotEligibleToImport();
826 if (!VTableFuncs.empty())
827 GVarSummary->setVTableFuncs(VTableFuncs);
828 Index.addGlobalValueSummary(V, std::move(GVarSummary));
836 if (isa<GlobalIFunc>(Aliasee))
840 A.getLinkage(),
A.getVisibility(), NonRenamableLocal,
841 false,
A.isDSOLocal(),
A.canBeOmittedFromSymbolTable(),
843 auto AS = std::make_unique<AliasSummary>(Flags);
844 auto AliaseeVI =
Index.getValueInfo(Aliasee->
getGUID());
845 assert(AliaseeVI &&
"Alias expects aliasee summary to be available");
846 assert(AliaseeVI.getSummaryList().size() == 1 &&
847 "Expected a single entry per aliasee in per-module index");
848 AS->setAliasee(AliaseeVI, AliaseeVI.getSummaryList()[0].get());
849 if (NonRenamableLocal)
850 CantBePromoted.
insert(
A.getGUID());
851 Index.addGlobalValueSummary(
A, std::move(AS));
857 for (
const auto &Summary : VI.getSummaryList())
858 Summary->setLive(
true);
867 bool EnableSplitLTOUnit =
false;
868 bool UnifiedLTO =
false;
869 if (
auto *MD = mdconst::extract_or_null<ConstantInt>(
870 M.getModuleFlag(
"EnableSplitLTOUnit")))
871 EnableSplitLTOUnit = MD->getZExtValue();
873 mdconst::extract_or_null<ConstantInt>(M.getModuleFlag(
"UnifiedLTO")))
874 UnifiedLTO = MD->getZExtValue();
889 for (
auto *V : Used) {
890 if (V->hasLocalLinkage()) {
892 CantBePromoted.
insert(V->getGUID());
896 bool HasLocalInlineAsmSymbol =
false;
897 if (!M.getModuleInlineAsm().empty()) {
913 HasLocalInlineAsmSymbol =
true;
926 if (
Function *
F = dyn_cast<Function>(GV)) {
927 std::unique_ptr<FunctionSummary> Summary =
928 std::make_unique<FunctionSummary>(
931 F->hasFnAttribute(Attribute::ReadNone),
932 F->hasFnAttribute(Attribute::ReadOnly),
933 F->hasFnAttribute(Attribute::NoRecurse),
934 F->returnDoesNotAlias(),
936 F->hasFnAttribute(Attribute::AlwaysInline),
937 F->hasFnAttribute(Attribute::NoUnwind),
950 Index.addGlobalValueSummary(*GV, std::move(Summary));
952 std::unique_ptr<GlobalVarSummary> Summary =
953 std::make_unique<GlobalVarSummary>(
956 false,
false, cast<GlobalVariable>(GV)->
isConstant(),
959 Index.addGlobalValueSummary(*GV, std::move(Summary));
964 bool IsThinLTO =
true;
966 mdconst::extract_or_null<ConstantInt>(M.getModuleFlag(
"ThinLTO")))
967 IsThinLTO = MD->getZExtValue();
971 for (
const auto &
F : M) {
972 if (
F.isDeclaration())
977 std::unique_ptr<BlockFrequencyInfo> BFIPtr;
979 BFI = GetBFICallback(
F);
980 else if (
F.hasProfileData()) {
983 BFIPtr = std::make_unique<BlockFrequencyInfo>(
F, BPI, LI);
988 !LocalsUsed.
empty() || HasLocalInlineAsmSymbol,
989 CantBePromoted, IsThinLTO, GetSSICallback);
996 if (
G.isDeclaration())
1009 Index.getGlobalValueSummary(GV)->setLive(
true);
1013 for (
auto *V : LocalsUsed) {
1014 auto *Summary =
Index.getGlobalValueSummary(*V);
1015 assert(Summary &&
"Missing summary for global value");
1016 Summary->setNotEligibleToImport();
1028 for (
auto &GlobalList :
Index) {
1030 if (GlobalList.second.SummaryList.empty())
1033 assert(GlobalList.second.SummaryList.size() == 1 &&
1034 "Expected module's index to have one summary per GUID");
1035 auto &Summary = GlobalList.second.SummaryList[0];
1037 Summary->setNotEligibleToImport();
1041 bool AllRefsCanBeExternallyReferenced =
1043 return !CantBePromoted.count(VI.getGUID());
1045 if (!AllRefsCanBeExternallyReferenced) {
1046 Summary->setNotEligibleToImport();
1050 if (
auto *FuncSummary = dyn_cast<FunctionSummary>(Summary.get())) {
1053 return !CantBePromoted.count(Edge.first.getGUID());
1055 if (!AllCallsCanBeExternallyReferenced)
1056 Summary->setNotEligibleToImport();
1066 Index.exportToDot(OSDot, {});
1096 "Module Summary Analysis",
false,
true)
1113 auto *PSI = &getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI();
1118 return &(this->getAnalysis<BlockFrequencyInfoWrapperPass>(
1124 return NeedSSI ? &getAnalysis<StackSafetyInfoWrapperPass>(
1164 "Module summary info",
false,
true)
1169 if (CB->isDebugOrPseudoInst())
1171 auto *CI = dyn_cast<CallInst>(CB);
1172 auto *CalledValue = CB->getCalledOperand();
1173 auto *CalledFunction = CB->getCalledFunction();
1174 if (CalledValue && !CalledFunction) {
1175 CalledValue = CalledValue->stripPointerCasts();
1177 CalledFunction = dyn_cast<Function>(CalledValue);
1181 if (
auto *GA = dyn_cast<GlobalAlias>(CalledValue)) {
1182 assert(!CalledFunction &&
1183 "Expected null called function in callsite for alias");
1184 CalledFunction = dyn_cast<Function>(GA->getAliaseeObject());
1188 if (CalledFunction) {
1189 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 bool findRefEdges(ModuleSummaryIndex &Index, const User *CurUser, SetVector< ValueInfo, std::vector< ValueInfo > > &RefEdges, SmallPtrSet< const User *, 8 > &Visited)
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.
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
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 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.