15#ifndef LLVM_IR_MODULESUMMARYINDEX_H
16#define LLVM_IR_MODULESUMMARYINDEX_H
49template <
class GraphType>
struct GraphTraits;
108 Temp /= Scaled64::get(EntryFreq);
133class GlobalValueSummary;
175 std::map<GlobalValue::GUID, GlobalValueSummaryInfo>;
185 ValueInfo(
bool HaveGVs,
const GlobalValueSummaryMapTy::value_type *R) {
195 return getRef()->second.U.GV;
199 return getRef()->second.SummaryList;
204 :
getRef()->second.U.Name;
235 const GlobalValueSummaryMapTy::value_type *
getRef()
const {
246 bool isDSOLocal(
bool WithDSOLocalPropagation =
false)
const;
254 if (!VI.name().empty())
255 OS <<
" (" << VI.name() <<
")";
261 "Need ValueInfo with non-null Ref for comparison");
262 return A.getRef() ==
B.getRef();
267 "Need ValueInfo with non-null Ref for comparison");
268 return A.getRef() !=
B.getRef();
273 "Need ValueInfo with non-null Ref to compare GUIDs");
274 return A.getGUID() <
B.getGUID();
279 return ValueInfo(
false, (GlobalValueSummaryMapTy::value_type *)-8);
283 return ValueInfo(
false, (GlobalValueSummaryMapTy::value_type *)-16);
287 return V == getTombstoneKey() || V == getEmptyKey();
293 assert(isSpecialKey(L) || isSpecialKey(R) || (L.haveGVs() == R.haveGVs()));
294 return L.getRef() == R.getRef();
332 for (
auto V : SNI.
Clones) {
422 for (
auto &M : AE.
MIBs) {
423 OS <<
"\t\t" << M <<
"\n";
526 std::vector<ValueInfo> RefEdgeList;
530 : Kind(K), Flags(Flags), RefEdgeList(
std::
move(Refs)) {
532 "Expect no references for AliasSummary");
566 Flags.Linkage = Linkage;
572 bool isLive()
const {
return Flags.Live; }
591 return static_cast<ImportKind>(Flags.ImportType);
630 AliaseeSummary(
nullptr) {}
638 AliaseeValueInfo = AliaseeVI;
639 AliaseeSummary = Aliasee;
643 assert(!!AliaseeSummary == (AliaseeValueInfo &&
645 "Expect to have both aliasee summary and summary list or neither");
646 return !!AliaseeSummary;
650 assert(AliaseeSummary &&
"Unexpected missing aliasee summary");
651 return *AliaseeSummary;
659 assert(AliaseeValueInfo &&
"Unexpected missing aliasee");
660 return AliaseeValueInfo;
663 assert(AliaseeValueInfo &&
"Unexpected missing aliasee");
664 return AliaseeValueInfo.
getGUID();
669 if (
auto *AS = dyn_cast<AliasSummary>(
this))
670 return &AS->getAliasee();
675 if (
auto *AS = dyn_cast<AliasSummary>(
this))
676 return &AS->getAliasee();
685 using EdgeTy = std::pair<ValueInfo, CalleeInfo>;
781 operator std::string() {
784 OS <<
"funcFlags: (";
786 OS <<
", readOnly: " << this->
ReadOnly;
787 OS <<
", noRecurse: " << this->
NoRecurse;
789 OS <<
", noInline: " << this->
NoInline;
791 OS <<
", noUnwind: " << this->
NoUnwind;
792 OS <<
", mayThrow: " << this->
MayThrow;
845 std::vector<ValueInfo>(), std::move(Edges),
846 std::vector<GlobalValue::GUID>(),
847 std::vector<FunctionSummary::VFuncId>(),
848 std::vector<FunctionSummary::VFuncId>(),
849 std::vector<FunctionSummary::ConstVCall>(),
850 std::vector<FunctionSummary::ConstVCall>(),
851 std::vector<FunctionSummary::ParamAccess>(),
852 std::vector<CallsiteInfo>(), std::vector<AllocInfo>());
872 std::vector<EdgeTy> CallGraphEdgeList;
874 std::unique_ptr<TypeIdInfo> TIdInfo;
877 using ParamAccessesTy = std::vector<ParamAccess>;
878 std::unique_ptr<ParamAccessesTy> ParamAccesses;
886 using CallsitesTy = std::vector<CallsiteInfo>;
887 std::unique_ptr<CallsitesTy> Callsites;
896 using AllocsTy = std::vector<AllocInfo>;
897 std::unique_ptr<AllocsTy> Allocs;
901 uint64_t EntryCount, std::vector<ValueInfo> Refs,
902 std::vector<EdgeTy> CGEdges,
903 std::vector<GlobalValue::GUID> TypeTests,
904 std::vector<VFuncId> TypeTestAssumeVCalls,
905 std::vector<VFuncId> TypeCheckedLoadVCalls,
906 std::vector<ConstVCall> TypeTestAssumeConstVCalls,
907 std::vector<ConstVCall> TypeCheckedLoadConstVCalls,
908 std::vector<ParamAccess> Params, CallsitesTy CallsiteList,
911 InstCount(NumInsts), FunFlags(FunFlags), EntryCount(EntryCount),
912 CallGraphEdgeList(
std::
move(CGEdges)) {
913 if (!TypeTests.empty() || !TypeTestAssumeVCalls.empty() ||
914 !TypeCheckedLoadVCalls.empty() || !TypeTestAssumeConstVCalls.empty() ||
915 !TypeCheckedLoadConstVCalls.empty())
916 TIdInfo = std::make_unique<TypeIdInfo>(
917 TypeIdInfo{std::move(TypeTests), std::move(TypeTestAssumeVCalls),
918 std::move(TypeCheckedLoadVCalls),
919 std::move(TypeTestAssumeConstVCalls),
920 std::move(TypeCheckedLoadConstVCalls)});
922 ParamAccesses = std::make_unique<ParamAccessesTy>(std::move(Params));
923 if (!CallsiteList.empty())
924 Callsites = std::make_unique<CallsitesTy>(std::move(CallsiteList));
925 if (!AllocList.empty())
926 Allocs = std::make_unique<AllocsTy>(std::move(AllocList));
964 return TIdInfo->TypeTests;
973 return TIdInfo->TypeTestAssumeVCalls;
982 return TIdInfo->TypeCheckedLoadVCalls;
991 return TIdInfo->TypeTestAssumeConstVCalls;
999 return TIdInfo->TypeCheckedLoadConstVCalls;
1006 return *ParamAccesses;
1012 if (NewParams.empty())
1013 ParamAccesses.reset();
1014 else if (ParamAccesses)
1015 *ParamAccesses = std::move(NewParams);
1017 ParamAccesses = std::make_unique<ParamAccessesTy>(std::move(NewParams));
1024 TIdInfo = std::make_unique<TypeIdInfo>();
1025 TIdInfo->TypeTests.push_back(
Guid);
1043 Callsites = std::make_unique<CallsitesTy>();
1044 Callsites->push_back(Callsite);
1069 return L.GUID == R.GUID && L.Offset == R.Offset;
1091 return I.VFunc.GUID;
1120 std::unique_ptr<VTableFuncList> VTableFuncs;
1154 std::vector<ValueInfo> Refs)
1178 VTableFuncs = std::make_unique<VTableFuncList>(std::move(Funcs));
1183 return *VTableFuncs;
1261 std::map<uint64_t, WholeProgramDevirtResolution>
WPDRes;
1285 std::multimap<GlobalValue::GUID, std::pair<std::string, TypeIdSummary>>;
1329 std::map<std::string, TypeIdCompatibleVtableInfo, std::less<>>
1330 TypeIdCompatibleVtableMap;
1334 std::map<GlobalValue::GUID, GlobalValue::GUID> OidGuidMap;
1339 bool WithGlobalValueDeadStripping =
false;
1344 bool WithAttributePropagation =
false;
1348 bool WithDSOLocalPropagation =
false;
1351 bool WithWholeProgramVisibility =
false;
1354 bool HasSyntheticEntryCounts =
false;
1357 bool WithSupportsHotColdNew =
false;
1364 bool SkipModuleByDistributedBackend =
false;
1373 bool EnableSplitLTOUnit;
1380 bool PartiallySplitLTOUnits =
false;
1383 bool HasParamAccess =
false;
1385 std::set<std::string> CfiFunctionDefs;
1386 std::set<std::string> CfiFunctionDecls;
1406 std::vector<uint64_t> StackIds;
1415 GlobalValueSummaryMapTy::value_type *
1424 bool UnifiedLTO =
false)
1425 : HaveGVs(HaveGVs), EnableSplitLTOUnit(EnableSplitLTOUnit),
1426 UnifiedLTO(UnifiedLTO), Saver(Alloc), BlockCount(0) {}
1437 return "[Regular LTO]";
1453 size_t size()
const {
return GlobalValueMap.size(); }
1455 const std::vector<uint64_t> &
stackIds()
const {
return StackIds; }
1458 auto Inserted = StackIdToIndex.
insert({StackId, StackIds.size()});
1459 if (Inserted.second)
1460 StackIds.push_back(StackId);
1461 return Inserted.first->second;
1466 return StackIds[
Index];
1475 assert(StackIdToIndex.
size() == StackIds.size());
1476 StackIdToIndex.
clear();
1477 StackIds.shrink_to_fit();
1483 std::map<ValueInfo, bool> &FunctionHasParent) {
1484 if (!V.getSummaryList().size())
1488 auto S = FunctionHasParent.emplace(V,
false);
1495 dyn_cast<FunctionSummary>(V.getSummaryList().front().get());
1496 assert(
F !=
nullptr &&
"Expected FunctionSummary node");
1498 for (
const auto &
C :
F->calls()) {
1500 auto S = FunctionHasParent.emplace(
C.first,
true);
1503 if (!S.second && S.first->second)
1509 S.first->second =
true;
1518 std::map<ValueInfo, bool> FunctionHasParent;
1520 for (
auto &S : *
this) {
1522 if (!S.second.SummaryList.size() ||
1523 !isa<FunctionSummary>(S.second.SummaryList.front().get()))
1528 std::vector<FunctionSummary::EdgeTy> Edges;
1530 for (
auto &
P : FunctionHasParent) {
1533 Edges.push_back(std::make_pair(
P.first,
CalleeInfo{}));
1535 if (Edges.empty()) {
1540 return CallGraphRoot;
1544 return WithGlobalValueDeadStripping;
1547 WithGlobalValueDeadStripping =
true;
1552 WithAttributePropagation =
true;
1575 return SkipModuleByDistributedBackend;
1578 SkipModuleByDistributedBackend =
true;
1593 return !WithGlobalValueDeadStripping || GVS->
isLive();
1605 auto I = GlobalValueMap.find(GUID);
1606 return ValueInfo(HaveGVs,
I == GlobalValueMap.end() ?
nullptr : &*
I);
1611 return ValueInfo(HaveGVs, getOrInsertValuePtr(GUID));
1622 auto VP = getOrInsertValuePtr(GUID);
1623 VP->second.U.Name =
Name;
1630 auto VP = getOrInsertValuePtr(GV->
getGUID());
1631 VP->second.U.GV = GV;
1637 const auto I = OidGuidMap.find(OriginalID);
1638 return I == OidGuidMap.end() ? 0 :
I->second;
1649 std::unique_ptr<GlobalValueSummary> Summary) {
1655 std::unique_ptr<GlobalValueSummary> Summary) {
1657 std::move(Summary));
1662 std::unique_ptr<GlobalValueSummary> Summary) {
1663 if (
const FunctionSummary *FS = dyn_cast<FunctionSummary>(Summary.get()))
1664 HasParamAccess |= !FS->paramAccesses().empty();
1668 const_cast<GlobalValueSummaryMapTy::value_type *
>(VI.getRef())
1669 ->second.SummaryList.push_back(std::move(Summary));
1675 if (OrigGUID == 0 || ValueGUID == OrigGUID)
1677 if (OidGuidMap.count(OrigGUID) && OidGuidMap[OrigGUID] != ValueGUID)
1678 OidGuidMap[OrigGUID] = 0;
1680 OidGuidMap[OrigGUID] = ValueGUID;
1686 auto SummaryList = VI.getSummaryList();
1689 [&](
const std::unique_ptr<GlobalValueSummary> &Summary) {
1690 return Summary->modulePath() == ModuleId;
1692 if (Summary == SummaryList.end())
1694 return Summary->get();
1710 bool PerModuleIndex =
true)
const {
1711 assert(GV.
hasName() &&
"Can't get GlobalValueSummary for GV with no name");
1719 bool PerModuleIndex =
true)
const;
1723 return ModulePathStringTable;
1731 auto It = ModulePathStringTable.
find(ModPath);
1732 assert(It != ModulePathStringTable.
end() &&
"Module not registered");
1739 std::string Suffix = utostr((
uint64_t(ModHash[0]) << 32) |
1746 NewName +=
".llvm.";
1748 return std::string(NewName);
1756 std::pair<StringRef, StringRef> Pair =
Name.rsplit(
".llvm.");
1765 return &*ModulePathStringTable.
insert({ModPath, Hash}).first;
1770 auto It = ModulePathStringTable.
find(ModPath);
1771 assert(It != ModulePathStringTable.
end() &&
"Module not registered");
1777 auto It = ModulePathStringTable.
find(ModPath);
1778 assert(It != ModulePathStringTable.
end() &&
"Module not registered");
1786 return ModulePathStringTable.
count(M.getModuleIdentifier());
1796 for (
auto It = TidIter.first; It != TidIter.second; ++It)
1797 if (It->second.first == TypeId)
1798 return It->second.second;
1799 auto It = TypeIdMap.insert(
1801 return It->second.second;
1808 for (
auto It = TidIter.first; It != TidIter.second; ++It)
1809 if (It->second.first == TypeId)
1810 return &It->second.second;
1821 return TypeIdCompatibleVtableMap;
1829 return TypeIdCompatibleVtableMap[std::string(TypeId)];
1834 std::optional<TypeIdCompatibleVtableInfo>
1836 auto I = TypeIdCompatibleVtableMap.find(TypeId);
1837 if (
I == TypeIdCompatibleVtableMap.end())
1838 return std::nullopt;
1849 template <
class Map>
1852 for (
const auto &GlobalList : *
this) {
1853 auto GUID = GlobalList.first;
1854 for (
const auto &Summary : GlobalList.second.SummaryList) {
1855 ModuleToDefinedGVSummaries[Summary->modulePath()][GUID] = Summary.get();
1891 decltype(&valueInfoFromEdge)>;
1898 if (!
N.getSummaryList().size())
1901 &valueInfoFromEdge);
1903 cast<FunctionSummary>(
N.getSummaryList().front()->getBaseObject());
1908 if (!
N.getSummaryList().size())
1911 &valueInfoFromEdge);
1913 cast<FunctionSummary>(
N.getSummaryList().front()->getBaseObject());
1918 if (!
N.getSummaryList().size())
1922 cast<FunctionSummary>(
N.getSummaryList().front()->getBaseObject());
1923 return F->CallGraphEdgeList.begin();
1927 if (!
N.getSummaryList().size())
1931 cast<FunctionSummary>(
N.getSummaryList().front()->getBaseObject());
1932 return F->CallGraphEdgeList.end();
1941 std::unique_ptr<GlobalValueSummary> Root =
1942 std::make_unique<FunctionSummary>(
I->calculateCallGraphRoot());
1944 G.SummaryList.push_back(std::move(Root));
for(const MachineOperand &MO :llvm::drop_begin(OldMI.operands(), Desc.getNumOperands()))
This file defines the StringMap class.
This file defines the BumpPtrAllocator interface.
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Looks at all the uses of the given value Returns the Liveness deduced from the uses of this value Adds all uses that cause the result to be MaybeLive to MaybeLiveRetUses If the result is Live
This file defines the DenseMap class.
static const char * PreservedSymbols[]
Module.h This file contains the declarations for the Module class.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallString class.
This file defines the SmallVector class.
ScaledNumber< uint64_t > Scaled64
Alias summary information.
GlobalValue::GUID getAliaseeGUID() const
const GlobalValueSummary & getAliasee() const
ValueInfo getAliaseeVI() const
static bool classof(const GlobalValueSummary *GVS)
Check if this is an alias summary.
AliasSummary(GVFlags Flags)
GlobalValueSummary & getAliasee()
void setAliasee(ValueInfo &AliaseeVI, GlobalValueSummary *Aliasee)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Allocate memory in an ever growing pool, as if by bump-pointer.
This class represents a range of values.
This is an important base class in LLVM.
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Implements a dense probed hash-table based set.
Function summary information to aid decisions and implementation of importing.
static FunctionSummary ExternalNode
A dummy node to reference external functions that aren't in the index.
void addCallsite(CallsiteInfo &Callsite)
FunctionSummary(GVFlags Flags, unsigned NumInsts, FFlags FunFlags, uint64_t EntryCount, std::vector< ValueInfo > Refs, std::vector< EdgeTy > CGEdges, std::vector< GlobalValue::GUID > TypeTests, std::vector< VFuncId > TypeTestAssumeVCalls, std::vector< VFuncId > TypeCheckedLoadVCalls, std::vector< ConstVCall > TypeTestAssumeConstVCalls, std::vector< ConstVCall > TypeCheckedLoadConstVCalls, std::vector< ParamAccess > Params, CallsitesTy CallsiteList, AllocsTy AllocList)
ArrayRef< VFuncId > type_test_assume_vcalls() const
Returns the list of virtual calls made by this function using llvm.assume(llvm.type....
AllocsTy & mutableAllocs()
ArrayRef< ConstVCall > type_test_assume_const_vcalls() const
Returns the list of virtual calls made by this function using llvm.assume(llvm.type....
static FunctionSummary makeDummyFunctionSummary(std::vector< FunctionSummary::EdgeTy > Edges)
Create an empty FunctionSummary (with specified call edges).
std::pair< ValueInfo, CalleeInfo > EdgeTy
<CalleeValueInfo, CalleeInfo> call edge pair.
std::pair< unsigned, unsigned > specialRefCounts() const
void setEntryCount(uint64_t EC)
Set the synthetic entry count for this function.
ArrayRef< AllocInfo > allocs() const
ArrayRef< CallsiteInfo > callsites() const
void addTypeTest(GlobalValue::GUID Guid)
Add a type test to the summary.
uint64_t entryCount() const
Get the synthetic entry count for this function.
std::vector< EdgeTy > & mutableCalls()
ArrayRef< VFuncId > type_checked_load_vcalls() const
Returns the list of virtual calls made by this function using llvm.type.checked.load intrinsics that ...
void setParamAccesses(std::vector< ParamAccess > NewParams)
Sets the list of known uses of pointer parameters.
unsigned instCount() const
Get the instruction count recorded for this function.
const TypeIdInfo * getTypeIdInfo() const
ArrayRef< ConstVCall > type_checked_load_const_vcalls() const
Returns the list of virtual calls made by this function using llvm.type.checked.load intrinsics with ...
ArrayRef< EdgeTy > calls() const
Return the list of <CalleeValueInfo, CalleeInfo> pairs.
ArrayRef< ParamAccess > paramAccesses() const
Returns the list of known uses of pointer parameters.
CallsitesTy & mutableCallsites()
ForceSummaryHotnessType
Types for -force-summary-edges-cold debugging option.
FFlags fflags() const
Get function summary flags.
ArrayRef< GlobalValue::GUID > type_tests() const
Returns the list of type identifiers used by this function in llvm.type.test intrinsics other than by...
static bool classof(const GlobalValueSummary *GVS)
Check if this is a function summary.
Function and variable summary information to aid decisions and implementation of importing.
SummaryKind
Sububclass discriminator (for dyn_cast<> et al.)
GVFlags flags() const
Get the flags for this GlobalValue (see struct GVFlags).
void setDSOLocal(bool Local)
StringRef modulePath() const
Get the path to the module containing this function.
GlobalValueSummary * getBaseObject()
If this is an alias summary, returns the summary of the aliased object (a global variable or function...
SummaryKind getSummaryKind() const
Which kind of summary subclass this is.
GlobalValue::GUID getOriginalName() const
Returns the hash of the original name, it is identical to the GUID for externally visible symbols,...
GlobalValue::VisibilityTypes getVisibility() const
ArrayRef< ValueInfo > refs() const
Return the list of values referenced by this global value definition.
bool shouldImportAsDecl() const
GlobalValueSummary(SummaryKind K, GVFlags Flags, std::vector< ValueInfo > Refs)
void setLinkage(GlobalValue::LinkageTypes Linkage)
Sets the linkage to the value determined by global summary-based optimization.
void setVisibility(GlobalValue::VisibilityTypes Vis)
virtual ~GlobalValueSummary()=default
GlobalValueSummary::ImportKind importType() const
void setModulePath(StringRef ModPath)
Set the path to the module containing this function, for use in the combined index.
void setNotEligibleToImport()
Flag that this global value cannot be imported.
void setCanAutoHide(bool CanAutoHide)
GlobalValue::LinkageTypes linkage() const
Return linkage type recorded for this global value.
bool notEligibleToImport() const
Return true if this global value can't be imported.
void setImportKind(ImportKind IK)
void setOriginalName(GlobalValue::GUID Name)
Initialize the original name hash in this summary.
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.
VisibilityTypes
An enumeration for the kinds of visibility of global values.
@ DefaultVisibility
The GV is visible.
LinkageTypes
An enumeration for the kinds of linkage for global values.
@ AvailableExternallyLinkage
Available for inspection, not emission.
Global variable summary information to aid decisions and implementation of importing.
void setWriteOnly(bool WO)
bool maybeWriteOnly() const
void setVCallVisibility(GlobalObject::VCallVisibility Vis)
struct llvm::GlobalVarSummary::GVarFlags VarFlags
GVarFlags varflags() const
bool maybeReadOnly() const
void setReadOnly(bool RO)
ArrayRef< VirtFuncOffset > vTableFuncs() const
GlobalObject::VCallVisibility getVCallVisibility() const
static bool classof(const GlobalValueSummary *GVS)
Check if this is a global variable summary.
GlobalVarSummary(GVFlags Flags, GVarFlags VarFlags, std::vector< ValueInfo > Refs)
void setVTableFuncs(VTableFuncList Funcs)
Class to hold module path string table and global value map, and encapsulate methods for operating on...
bool withAttributePropagation() const
std::set< std::string > & cfiFunctionDecls()
const std::set< std::string > & cfiFunctionDecls() const
TypeIdSummary & getOrInsertTypeIdSummary(StringRef TypeId)
Return an existing or new TypeIdSummary entry for TypeId.
std::optional< TypeIdCompatibleVtableInfo > getTypeIdCompatibleVtableSummary(StringRef TypeId) const
For the given TypeId, this returns the TypeIdCompatibleVtableMap entry if present in the summary map.
void addGlobalValueSummary(ValueInfo VI, std::unique_ptr< GlobalValueSummary > Summary)
Add a global value summary for the given ValueInfo.
ModulePathStringTableTy::value_type ModuleInfo
uint64_t getBlockCount() const
ValueInfo getOrInsertValueInfo(GlobalValue::GUID GUID)
Return a ValueInfo for GUID.
bool withGlobalValueDeadStripping() const
const std::set< std::string > & cfiFunctionDefs() const
static void discoverNodes(ValueInfo V, std::map< ValueInfo, bool > &FunctionHasParent)
Convenience function for doing a DFS on a ValueInfo.
StringRef saveString(StringRef String)
bool withWholeProgramVisibility() const
const TypeIdSummaryMapTy & typeIds() const
static StringRef getOriginalNameBeforePromote(StringRef Name)
Helper to obtain the unpromoted name for a global value (or the original name if not promoted).
const TypeIdSummary * getTypeIdSummary(StringRef TypeId) const
This returns either a pointer to the type id summary (if present in the summary map) or null (if not ...
bool isGUIDLive(GlobalValue::GUID GUID) const
gvsummary_iterator begin()
const_gvsummary_iterator end() const
bool isReadOnly(const GlobalVarSummary *GVS) const
void setFlags(uint64_t Flags)
const_gvsummary_iterator begin() const
bool isWriteOnly(const GlobalVarSummary *GVS) const
void addBlockCount(uint64_t C)
void setPartiallySplitLTOUnits()
const std::vector< uint64_t > & stackIds() const
GlobalValueSummary * findSummaryInModule(GlobalValue::GUID ValueGUID, StringRef ModuleId) const
Find the summary for global GUID in module ModuleId, or nullptr if not found.
void releaseTemporaryMemory()
void setBlockCount(uint64_t C)
ValueInfo getValueInfo(const GlobalValueSummaryMapTy::value_type &R) const
Return a ValueInfo for the index value_type (convenient when iterating index).
const ModuleHash & getModuleHash(const StringRef ModPath) const
Get the module SHA1 hash recorded for the given module path.
static constexpr const char * getRegularLTOModuleName()
void setEnableSplitLTOUnit()
void setHasSyntheticEntryCounts()
void addGlobalValueSummary(StringRef ValueName, std::unique_ptr< GlobalValueSummary > Summary)
Add a global value summary for a value of the given name.
ModuleSummaryIndex(bool HaveGVs, bool EnableSplitLTOUnit=false, bool UnifiedLTO=false)
bool hasSyntheticEntryCounts() const
bool partiallySplitLTOUnits() const
void collectDefinedFunctionsForModule(StringRef ModulePath, GVSummaryMapTy &GVSummaryMap) const
Collect for the given module the list of functions it defines (GUID -> Summary).
const auto & typeIdCompatibleVtableMap() const
void dumpSCCs(raw_ostream &OS)
Print out strongly connected components for debugging.
bool isGlobalValueLive(const GlobalValueSummary *GVS) const
bool enableSplitLTOUnit() const
void setWithSupportsHotColdNew()
const ModuleInfo * getModule(StringRef ModPath) const
Return module entry for module with the given ModPath.
void propagateAttributes(const DenseSet< GlobalValue::GUID > &PreservedSymbols)
Do the access attribute and DSOLocal propagation in combined index.
void setSkipModuleByDistributedBackend()
void setWithAttributePropagation()
const StringMap< ModuleHash > & modulePaths() const
Table of modules, containing module hash and id.
bool withSupportsHotColdNew() const
void dump() const
Dump to stderr (for debugging).
ModuleInfo * addModule(StringRef ModPath, ModuleHash Hash=ModuleHash{{0}})
Add a new module with the given Hash, mapped to the given ModID, and return a reference to the module...
void collectDefinedGVSummariesPerModule(Map &ModuleToDefinedGVSummaries) const
Collect for each module the list of Summaries it defines (GUID -> Summary).
void addGlobalValueSummary(const GlobalValue &GV, std::unique_ptr< GlobalValueSummary > Summary)
Add a global value summary for a value.
bool hasExportedFunctions(const Module &M) const
Check if the given Module has any functions available for exporting in the index.
static std::string getGlobalNameForLocal(StringRef Name, ModuleHash ModHash)
Convenience method for creating a promoted global name for the given value name of a local,...
static constexpr uint64_t BitcodeSummaryVersion
bool withDSOLocalPropagation() const
void exportToDot(raw_ostream &OS, const DenseSet< GlobalValue::GUID > &GUIDPreservedSymbols) const
Export summary to dot file for GraphViz.
bool hasUnifiedLTO() const
bool hasParamAccess() const
void setWithDSOLocalPropagation()
uint64_t getStackIdAtIndex(unsigned Index) const
StringMap< ModuleHash > & modulePaths()
Table of modules, containing hash and id.
void print(raw_ostream &OS, bool IsForDebug=false) const
Print to an output stream.
bool skipModuleByDistributedBackend() const
ValueInfo getOrInsertValueInfo(const GlobalValue *GV)
Return a ValueInfo for GV and mark it as belonging to GV.
GlobalValueSummary * findSummaryInModule(ValueInfo VI, StringRef ModuleId) const
Find the summary for ValueInfo VI in module ModuleId, or nullptr if not found.
ValueInfo getValueInfo(GlobalValue::GUID GUID) const
Return a ValueInfo for GUID if it exists, otherwise return ValueInfo().
uint64_t getFlags() const
unsigned addOrGetStackIdIndex(uint64_t StackId)
GlobalValue::GUID getGUIDFromOriginalID(GlobalValue::GUID OriginalID) const
Return the GUID for OriginalId in the OidGuidMap.
GlobalValueSummary * getGlobalValueSummary(const GlobalValue &GV, bool PerModuleIndex=true) const
Returns the first GlobalValueSummary for GV, asserting that there is only one if PerModuleIndex.
std::set< std::string > & cfiFunctionDefs()
void setWithGlobalValueDeadStripping()
ModuleInfo * getModule(StringRef ModPath)
Return module entry for module with the given ModPath.
ValueInfo getOrInsertValueInfo(GlobalValue::GUID GUID, StringRef Name)
Return a ValueInfo for GUID setting value Name.
void setWithWholeProgramVisibility()
bool canImportGlobalVar(const GlobalValueSummary *S, bool AnalyzeRefs) const
Checks if we can import global variable from another module.
static std::string getGlobalNameForLocal(StringRef Name, StringRef Suffix)
void addOriginalName(GlobalValue::GUID ValueGUID, GlobalValue::GUID OrigGUID)
Add an original name for the value of the given GUID.
FunctionSummary calculateCallGraphRoot()
TypeIdSummary * getTypeIdSummary(StringRef TypeId)
TypeIdCompatibleVtableInfo & getOrInsertTypeIdCompatibleVtableSummary(StringRef TypeId)
Return an existing or new TypeIdCompatibleVtableMap entry for TypeId.
A Module instance is used to store all the information related to an LLVM module.
PointerIntPair - This class implements a pair of a pointer and small integer.
void setPointer(PointerTy PtrVal) &
void setInt(IntType IntVal) &
PointerTy getPointer() const
Simple representation of a scaled number.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringMapEntry - This is used to represent one value that is inserted into a StringMap.
iterator find(StringRef Key)
size_type count(StringRef Key) const
count - Return 1 if the element is in the map, 0 otherwise.
bool insert(MapEntryTy *KeyValue)
insert - Insert the specified key/value pair into the map.
StringRef - Represent a constant reference to a string, i.e.
Saves strings in the provided stable storage and returns a StringRef with a stable character pointer.
StringRef save(const char *S)
A Use represents the edge between a Value definition and its users.
This class implements an extremely fast bulk output stream that can only output to a stream.
A raw_ostream that writes to an std::string.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ Cold
Attempts to make code in the caller as efficient as possible under the assumption that the call is no...
@ C
The default llvm calling convention, compatible with C.
This is an optimization pass for GlobalISel generic memory operations.
GlobalValueSummaryMapTy::iterator gvsummary_iterator
bool operator<(int64_t V1, const APSInt &V2)
const char * getHotnessName(CalleeInfo::HotnessType HT)
bool operator!=(uint64_t V1, const APInt &V2)
bool operator==(const AddressRangeValuePair &LHS, const AddressRangeValuePair &RHS)
std::vector< VirtFuncOffset > VTableFuncList
List of functions referenced by a particular vtable definition.
std::vector< std::unique_ptr< GlobalValueSummary > > GlobalValueSummaryList
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
GlobalValueSummaryMapTy::const_iterator const_gvsummary_iterator
Type used for iterating through the global value summary map.
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
std::multimap< GlobalValue::GUID, std::pair< std::string, TypeIdSummary > > TypeIdSummaryMapTy
Map of a type GUID to type id string and summary (multimap used in case of GUID conflicts).
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
std::array< uint32_t, 5 > ModuleHash
160 bits SHA1
std::map< GlobalValue::GUID, GlobalValueSummaryInfo > GlobalValueSummaryMapTy
Map from global value GUID to corresponding summary structures.
std::vector< TypeIdOffsetVtableInfo > TypeIdCompatibleVtableInfo
List of vtable definitions decorated by a particular type identifier, and their corresponding offsets...
Implement std::hash so that hash_code can be used in STL containers.
Summary of memprof metadata on allocations.
AllocInfo(std::vector< MIBInfo > MIBs)
AllocInfo(SmallVector< uint8_t > Versions, std::vector< MIBInfo > MIBs)
SmallVector< uint8_t > Versions
std::vector< MIBInfo > MIBs
Class to accumulate and hold information about a callee.
static constexpr uint64_t MaxRelBlockFreq
void updateHotness(const HotnessType OtherHotness)
CalleeInfo(HotnessType Hotness, bool HasTC, uint64_t RelBF)
HotnessType getHotness() const
static constexpr int32_t ScaleShift
void setHasTailCall(const bool HasTC)
void updateRelBlockFreq(uint64_t BlockFreq, uint64_t EntryFreq)
Update RelBlockFreq from BlockFreq and EntryFreq.
static constexpr unsigned RelBlockFreqBits
The value stored in RelBlockFreq has to be interpreted as the digits of a scaled number with a scale ...
Summary of memprof callsite metadata.
SmallVector< unsigned > StackIdIndices
SmallVector< unsigned > Clones
CallsiteInfo(ValueInfo Callee, SmallVector< unsigned > StackIdIndices)
CallsiteInfo(ValueInfo Callee, SmallVector< unsigned > Clones, SmallVector< unsigned > StackIdIndices)
static FunctionSummary::ConstVCall getEmptyKey()
static FunctionSummary::ConstVCall getTombstoneKey()
static unsigned getHashValue(FunctionSummary::ConstVCall I)
static bool isEqual(FunctionSummary::ConstVCall L, FunctionSummary::ConstVCall R)
static FunctionSummary::VFuncId getEmptyKey()
static bool isEqual(FunctionSummary::VFuncId L, FunctionSummary::VFuncId R)
static FunctionSummary::VFuncId getTombstoneKey()
static unsigned getHashValue(FunctionSummary::VFuncId I)
static bool isEqual(ValueInfo L, ValueInfo R)
static ValueInfo getEmptyKey()
static ValueInfo getTombstoneKey()
static bool isSpecialKey(ValueInfo V)
static unsigned getHashValue(ValueInfo I)
An information struct used to provide DenseMap with the various necessary components for a given valu...
A specification for a virtual function call with all constant integer arguments.
std::vector< uint64_t > Args
Flags specific to function summaries.
FFlags & operator&=(const FFlags &RHS)
unsigned ReturnDoesNotAlias
unsigned MustBeUnreachable
Describes the use of a value in a call instruction, specifying the call's target, the value's paramet...
Call(uint64_t ParamNo, ValueInfo Callee, const ConstantRange &Offsets)
Describes the uses of a parameter by the function.
ParamAccess(uint64_t ParamNo, const ConstantRange &Use)
std::vector< Call > Calls
In the per-module summary, it summarizes the byte offset applied to each pointer parameter before pas...
static constexpr uint32_t RangeWidth
All type identifier related information.
std::vector< ConstVCall > TypeCheckedLoadConstVCalls
std::vector< VFuncId > TypeCheckedLoadVCalls
std::vector< ConstVCall > TypeTestAssumeConstVCalls
List of virtual calls made by this function using (respectively) llvm.assume(llvm....
std::vector< GlobalValue::GUID > TypeTests
List of type identifiers used by this function in llvm.type.test intrinsics referenced by something o...
std::vector< VFuncId > TypeTestAssumeVCalls
List of virtual calls made by this function using (respectively) llvm.assume(llvm....
An "identifier" for a virtual function.
GlobalValueSummaryList SummaryList
List of global value summary structures for a particular value held in the GlobalValueMap.
GlobalValueSummaryInfo(bool HaveGVs)
union llvm::GlobalValueSummaryInfo::NameOrGV U
Group flags (Linkage, NotEligibleToImport, etc.) as a bitfield.
GVFlags(GlobalValue::LinkageTypes Linkage, GlobalValue::VisibilityTypes Visibility, bool NotEligibleToImport, bool Live, bool IsLocal, bool CanAutoHide, ImportKind ImportType)
Convenience Constructors.
unsigned DSOLocal
Indicates that the linker resolved the symbol to a definition from within the same linkage unit.
unsigned CanAutoHide
In the per-module summary, indicates that the global value is linkonce_odr and global unnamed addr (s...
unsigned ImportType
This field is written by the ThinLTO indexing step to postlink combined summary.
unsigned NotEligibleToImport
Indicate if the global value cannot be imported (e.g.
unsigned Linkage
The linkage type of the associated global value.
unsigned Visibility
Indicates the visibility.
unsigned Live
In per-module summary, indicate that the global value must be considered a live root for index-based ...
GVarFlags(bool ReadOnly, bool WriteOnly, bool Constant, GlobalObject::VCallVisibility Vis)
static NodeRef getEntryNode(ModuleSummaryIndex *I)
static NodeRef valueInfoFromEdge(FunctionSummary::EdgeTy &P)
static ChildIteratorType child_begin(NodeRef N)
static ChildEdgeIteratorType child_edge_begin(NodeRef N)
static NodeRef edge_dest(EdgeRef E)
std::vector< FunctionSummary::EdgeTy >::iterator ChildEdgeIteratorType
static NodeRef getEntryNode(ValueInfo V)
static ChildIteratorType child_end(NodeRef N)
static ChildEdgeIteratorType child_edge_end(NodeRef N)
FunctionSummary::EdgeTy & EdgeRef
Summary of a single MIB in a memprof metadata on allocations.
MIBInfo(AllocationType AllocType, SmallVector< unsigned > StackIdIndices)
SmallVector< unsigned > StackIdIndices
The following data structures summarize type metadata information.
TypeIdOffsetVtableInfo(uint64_t Offset, ValueInfo VI)
uint64_t AddressPointOffset
std::map< uint64_t, WholeProgramDevirtResolution > WPDRes
Mapping from byte offset to whole-program devirt resolution for that (typeid, byte offset) pair.
Kind
Specifies which kind of type check we should emit for this byte array.
@ Unknown
Unknown (analysis not performed, don't lower)
@ Single
Single element (last example in "Short Inline Bit Vectors")
@ Inline
Inlined bit vector ("Short Inline Bit Vectors")
@ Unsat
Unsatisfiable type (i.e. no global has this type metadata)
@ AllOnes
All-ones bit vector ("Eliminating Bit Vector Checks for All-Ones Bit Vectors")
@ ByteArray
Test a byte array (first example)
unsigned SizeM1BitWidth
Range of size-1 expressed as a bit width.
enum llvm::TypeTestResolution::Kind TheKind
Struct that holds a reference to a particular GUID in a global value summary.
PointerIntPair< const GlobalValueSummaryMapTy::value_type *, 3, int > RefAndFlags
GlobalValue::VisibilityTypes getELFVisibility() const
Returns the most constraining visibility among summaries.
bool isValidAccessSpecifier() const
const GlobalValueSummaryMapTy::value_type * getRef() const
ArrayRef< std::unique_ptr< GlobalValueSummary > > getSummaryList() const
const GlobalValue * getValue() const
ValueInfo(bool HaveGVs, const GlobalValueSummaryMapTy::value_type *R)
bool canAutoHide() const
Checks if all copies are eligible for auto-hiding (have flag set).
unsigned getAccessSpecifier() const
bool isDSOLocal(bool WithDSOLocalPropagation=false) const
Checks if all summaries are DSO local (have the flag set).
GlobalValue::GUID getGUID() const
The ValueInfo and offset for a function within a vtable definition initializer array.
VirtFuncOffset(ValueInfo VI, uint64_t Offset)
@ UniformRetVal
Uniform return value optimization.
@ VirtualConstProp
Virtual constant propagation.
@ UniqueRetVal
Unique return value optimization.
@ Indir
Just do a regular virtual call.
uint64_t Info
Additional information for the resolution:
enum llvm::WholeProgramDevirtResolution::ByArg::Kind TheKind
enum llvm::WholeProgramDevirtResolution::Kind TheKind
std::map< std::vector< uint64_t >, ByArg > ResByArg
Resolutions for calls with all constant integer arguments (excluding the first argument,...
std::string SingleImplName
@ SingleImpl
Single implementation devirtualization.
@ Indir
Just do a regular virtual call.
@ BranchFunnel
When retpoline mitigation is enabled, use a branch funnel that is defined in the merged module.
const GlobalValue * GV
The GlobalValue corresponding to this summary.
StringRef Name
Summary string representation.