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";
509 std::vector<ValueInfo> RefEdgeList;
513 : Kind(K), Flags(Flags), RefEdgeList(
std::
move(Refs)) {
515 "Expect no references for AliasSummary");
549 Flags.Linkage = Linkage;
555 bool isLive()
const {
return Flags.Live; }
603 AliaseeSummary(
nullptr) {}
611 AliaseeValueInfo = AliaseeVI;
612 AliaseeSummary = Aliasee;
616 assert(!!AliaseeSummary == (AliaseeValueInfo &&
618 "Expect to have both aliasee summary and summary list or neither");
619 return !!AliaseeSummary;
623 assert(AliaseeSummary &&
"Unexpected missing aliasee summary");
624 return *AliaseeSummary;
632 assert(AliaseeValueInfo &&
"Unexpected missing aliasee");
633 return AliaseeValueInfo;
636 assert(AliaseeValueInfo &&
"Unexpected missing aliasee");
637 return AliaseeValueInfo.
getGUID();
642 if (
auto *AS = dyn_cast<AliasSummary>(
this))
643 return &AS->getAliasee();
648 if (
auto *AS = dyn_cast<AliasSummary>(
this))
649 return &AS->getAliasee();
658 using EdgeTy = std::pair<ValueInfo, CalleeInfo>;
754 operator std::string() {
757 OS <<
"funcFlags: (";
759 OS <<
", readOnly: " << this->
ReadOnly;
760 OS <<
", noRecurse: " << this->
NoRecurse;
762 OS <<
", noInline: " << this->
NoInline;
764 OS <<
", noUnwind: " << this->
NoUnwind;
765 OS <<
", mayThrow: " << this->
MayThrow;
818 std::vector<ValueInfo>(), std::move(Edges),
819 std::vector<GlobalValue::GUID>(),
820 std::vector<FunctionSummary::VFuncId>(),
821 std::vector<FunctionSummary::VFuncId>(),
822 std::vector<FunctionSummary::ConstVCall>(),
823 std::vector<FunctionSummary::ConstVCall>(),
824 std::vector<FunctionSummary::ParamAccess>(),
825 std::vector<CallsiteInfo>(), std::vector<AllocInfo>());
845 std::vector<EdgeTy> CallGraphEdgeList;
847 std::unique_ptr<TypeIdInfo> TIdInfo;
850 using ParamAccessesTy = std::vector<ParamAccess>;
851 std::unique_ptr<ParamAccessesTy> ParamAccesses;
859 using CallsitesTy = std::vector<CallsiteInfo>;
860 std::unique_ptr<CallsitesTy> Callsites;
869 using AllocsTy = std::vector<AllocInfo>;
870 std::unique_ptr<AllocsTy> Allocs;
874 uint64_t EntryCount, std::vector<ValueInfo> Refs,
875 std::vector<EdgeTy> CGEdges,
876 std::vector<GlobalValue::GUID> TypeTests,
877 std::vector<VFuncId> TypeTestAssumeVCalls,
878 std::vector<VFuncId> TypeCheckedLoadVCalls,
879 std::vector<ConstVCall> TypeTestAssumeConstVCalls,
880 std::vector<ConstVCall> TypeCheckedLoadConstVCalls,
881 std::vector<ParamAccess> Params, CallsitesTy CallsiteList,
884 InstCount(NumInsts), FunFlags(FunFlags), EntryCount(EntryCount),
885 CallGraphEdgeList(
std::
move(CGEdges)) {
886 if (!TypeTests.empty() || !TypeTestAssumeVCalls.empty() ||
887 !TypeCheckedLoadVCalls.empty() || !TypeTestAssumeConstVCalls.empty() ||
888 !TypeCheckedLoadConstVCalls.empty())
889 TIdInfo = std::make_unique<TypeIdInfo>(
890 TypeIdInfo{std::move(TypeTests), std::move(TypeTestAssumeVCalls),
891 std::move(TypeCheckedLoadVCalls),
892 std::move(TypeTestAssumeConstVCalls),
893 std::move(TypeCheckedLoadConstVCalls)});
895 ParamAccesses = std::make_unique<ParamAccessesTy>(std::move(Params));
896 if (!CallsiteList.empty())
897 Callsites = std::make_unique<CallsitesTy>(std::move(CallsiteList));
898 if (!AllocList.empty())
899 Allocs = std::make_unique<AllocsTy>(std::move(AllocList));
937 return TIdInfo->TypeTests;
946 return TIdInfo->TypeTestAssumeVCalls;
955 return TIdInfo->TypeCheckedLoadVCalls;
964 return TIdInfo->TypeTestAssumeConstVCalls;
972 return TIdInfo->TypeCheckedLoadConstVCalls;
979 return *ParamAccesses;
985 if (NewParams.empty())
986 ParamAccesses.reset();
987 else if (ParamAccesses)
988 *ParamAccesses = std::move(NewParams);
990 ParamAccesses = std::make_unique<ParamAccessesTy>(std::move(NewParams));
997 TIdInfo = std::make_unique<TypeIdInfo>();
998 TIdInfo->TypeTests.push_back(Guid);
1036 return L.GUID == R.GUID && L.Offset == R.Offset;
1058 return I.VFunc.GUID;
1087 std::unique_ptr<VTableFuncList> VTableFuncs;
1121 std::vector<ValueInfo> Refs)
1145 VTableFuncs = std::make_unique<VTableFuncList>(std::move(Funcs));
1150 return *VTableFuncs;
1228 std::map<uint64_t, WholeProgramDevirtResolution>
WPDRes;
1249 std::multimap<GlobalValue::GUID, std::pair<std::string, TypeIdSummary>>;
1293 std::map<std::string, TypeIdCompatibleVtableInfo, std::less<>>
1294 TypeIdCompatibleVtableMap;
1298 std::map<GlobalValue::GUID, GlobalValue::GUID> OidGuidMap;
1303 bool WithGlobalValueDeadStripping =
false;
1308 bool WithAttributePropagation =
false;
1312 bool WithDSOLocalPropagation =
false;
1315 bool WithWholeProgramVisibility =
false;
1318 bool HasSyntheticEntryCounts =
false;
1321 bool WithSupportsHotColdNew =
false;
1328 bool SkipModuleByDistributedBackend =
false;
1337 bool EnableSplitLTOUnit;
1344 bool PartiallySplitLTOUnits =
false;
1347 bool HasParamAccess =
false;
1349 std::set<std::string> CfiFunctionDefs;
1350 std::set<std::string> CfiFunctionDecls;
1370 std::vector<uint64_t> StackIds;
1374 std::map<uint64_t, unsigned> StackIdToIndex;
1379 GlobalValueSummaryMapTy::value_type *
1388 bool UnifiedLTO =
false)
1389 : HaveGVs(HaveGVs), EnableSplitLTOUnit(EnableSplitLTOUnit),
1390 UnifiedLTO(UnifiedLTO), Saver(Alloc), BlockCount(0) {}
1401 return "[Regular LTO]";
1417 size_t size()
const {
return GlobalValueMap.size(); }
1419 const std::vector<uint64_t> &
stackIds()
const {
return StackIds; }
1422 auto Inserted = StackIdToIndex.insert({StackId, StackIds.size()});
1423 if (Inserted.second)
1424 StackIds.push_back(StackId);
1425 return Inserted.first->second;
1430 return StackIds[
Index];
1439 assert(StackIdToIndex.size() == StackIds.size());
1440 StackIdToIndex.clear();
1441 StackIds.shrink_to_fit();
1447 std::map<ValueInfo, bool> &FunctionHasParent) {
1448 if (!V.getSummaryList().size())
1452 auto S = FunctionHasParent.emplace(V,
false);
1459 dyn_cast<FunctionSummary>(V.getSummaryList().front().get());
1460 assert(
F !=
nullptr &&
"Expected FunctionSummary node");
1462 for (
const auto &
C :
F->calls()) {
1464 auto S = FunctionHasParent.emplace(
C.first,
true);
1467 if (!S.second && S.first->second)
1473 S.first->second =
true;
1482 std::map<ValueInfo, bool> FunctionHasParent;
1484 for (
auto &S : *
this) {
1486 if (!S.second.SummaryList.size() ||
1487 !isa<FunctionSummary>(S.second.SummaryList.front().get()))
1492 std::vector<FunctionSummary::EdgeTy> Edges;
1494 for (
auto &
P : FunctionHasParent) {
1497 Edges.push_back(std::make_pair(
P.first,
CalleeInfo{}));
1499 if (Edges.empty()) {
1504 return CallGraphRoot;
1508 return WithGlobalValueDeadStripping;
1511 WithGlobalValueDeadStripping =
true;
1516 WithAttributePropagation =
true;
1539 return SkipModuleByDistributedBackend;
1542 SkipModuleByDistributedBackend =
true;
1557 return !WithGlobalValueDeadStripping || GVS->
isLive();
1569 auto I = GlobalValueMap.find(GUID);
1570 return ValueInfo(HaveGVs,
I == GlobalValueMap.end() ?
nullptr : &*
I);
1575 return ValueInfo(HaveGVs, getOrInsertValuePtr(GUID));
1586 auto VP = getOrInsertValuePtr(GUID);
1587 VP->second.U.Name =
Name;
1594 auto VP = getOrInsertValuePtr(GV->
getGUID());
1595 VP->second.U.GV = GV;
1601 const auto I = OidGuidMap.find(OriginalID);
1602 return I == OidGuidMap.end() ? 0 :
I->second;
1613 std::unique_ptr<GlobalValueSummary> Summary) {
1619 std::unique_ptr<GlobalValueSummary> Summary) {
1621 std::move(Summary));
1626 std::unique_ptr<GlobalValueSummary> Summary) {
1627 if (
const FunctionSummary *FS = dyn_cast<FunctionSummary>(Summary.get()))
1628 HasParamAccess |= !FS->paramAccesses().empty();
1632 const_cast<GlobalValueSummaryMapTy::value_type *
>(VI.getRef())
1633 ->second.SummaryList.push_back(std::move(Summary));
1639 if (OrigGUID == 0 || ValueGUID == OrigGUID)
1641 if (OidGuidMap.count(OrigGUID) && OidGuidMap[OrigGUID] != ValueGUID)
1642 OidGuidMap[OrigGUID] = 0;
1644 OidGuidMap[OrigGUID] = ValueGUID;
1650 auto SummaryList = VI.getSummaryList();
1653 [&](
const std::unique_ptr<GlobalValueSummary> &Summary) {
1654 return Summary->modulePath() == ModuleId;
1656 if (Summary == SummaryList.end())
1658 return Summary->get();
1674 bool PerModuleIndex =
true)
const {
1675 assert(GV.
hasName() &&
"Can't get GlobalValueSummary for GV with no name");
1683 bool PerModuleIndex =
true)
const;
1687 return ModulePathStringTable;
1695 auto It = ModulePathStringTable.
find(ModPath);
1696 assert(It != ModulePathStringTable.
end() &&
"Module not registered");
1703 std::string Suffix = utostr((
uint64_t(ModHash[0]) << 32) |
1710 NewName +=
".llvm.";
1712 return std::string(NewName.
str());
1720 std::pair<StringRef, StringRef> Pair =
Name.rsplit(
".llvm.");
1729 return &*ModulePathStringTable.
insert({ModPath, Hash}).first;
1734 auto It = ModulePathStringTable.
find(ModPath);
1735 assert(It != ModulePathStringTable.
end() &&
"Module not registered");
1741 auto It = ModulePathStringTable.
find(ModPath);
1742 assert(It != ModulePathStringTable.
end() &&
"Module not registered");
1750 return ModulePathStringTable.
count(M.getModuleIdentifier());
1760 for (
auto It = TidIter.first; It != TidIter.second; ++It)
1761 if (It->second.first == TypeId)
1762 return It->second.second;
1763 auto It = TypeIdMap.insert(
1765 return It->second.second;
1772 for (
auto It = TidIter.first; It != TidIter.second; ++It)
1773 if (It->second.first == TypeId)
1774 return &It->second.second;
1785 return TypeIdCompatibleVtableMap;
1793 return TypeIdCompatibleVtableMap[std::string(TypeId)];
1798 std::optional<TypeIdCompatibleVtableInfo>
1800 auto I = TypeIdCompatibleVtableMap.find(TypeId);
1801 if (
I == TypeIdCompatibleVtableMap.end())
1802 return std::nullopt;
1813 template <
class Map>
1816 for (
const auto &GlobalList : *
this) {
1817 auto GUID = GlobalList.first;
1818 for (
const auto &Summary : GlobalList.second.SummaryList) {
1819 ModuleToDefinedGVSummaries[Summary->modulePath()][GUID] = Summary.get();
1855 decltype(&valueInfoFromEdge)>;
1862 if (!
N.getSummaryList().size())
1865 &valueInfoFromEdge);
1867 cast<FunctionSummary>(
N.getSummaryList().front()->getBaseObject());
1872 if (!
N.getSummaryList().size())
1875 &valueInfoFromEdge);
1877 cast<FunctionSummary>(
N.getSummaryList().front()->getBaseObject());
1882 if (!
N.getSummaryList().size())
1886 cast<FunctionSummary>(
N.getSummaryList().front()->getBaseObject());
1887 return F->CallGraphEdgeList.begin();
1891 if (!
N.getSummaryList().size())
1895 cast<FunctionSummary>(
N.getSummaryList().front()->getBaseObject());
1896 return F->CallGraphEdgeList.end();
1905 std::unique_ptr<GlobalValueSummary> Root =
1906 std::make_unique<FunctionSummary>(
I->calculateCallGraphRoot());
1908 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.
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.
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.
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
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 setOriginalName(GlobalValue::GUID Name)
Initialize the original name hash in this summary.
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.
static GUID getGUID(StringRef GlobalName)
Return a 64-bit global unique ID constructed from global value name (i.e.
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.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
StringRef str() const
Explicit conversion to StringRef.
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)
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 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.