1//===-- ModuleSummaryIndex.cpp - Module Summary Index ---------------------===// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7//===----------------------------------------------------------------------===// 9// This file implements the module index and summary classes for the 12//===----------------------------------------------------------------------===// 22#define DEBUG_TYPE "module-summary-index" 25"Number of live global variables marked read only");
27"Number of live global variables marked write only");
31cl::desc(
"Propagate attributes in index"));
35cl::desc(
"Import constant global variables with references"));
44bool HasProtected =
false;
56// With DSOLocal propagation done, the flag in evey summary is the same. 57// Check the first one is enough. 58return WithDSOLocalPropagation
63 [](
const std::unique_ptr<GlobalValueSummary> &Summary) {
64return Summary->isDSOLocal();
69// Can only auto hide if all copies are eligible to auto hide. 72 [](
const std::unique_ptr<GlobalValueSummary> &Summary) {
73return Summary->canAutoHide();
77// Gets the number of readonly and writeonly refs in RefEdgeList 79// Here we take advantage of having all readonly and writeonly references 80// located in the end of the RefEdgeList. 82unsigned RORefCnt = 0, WORefCnt = 0;
84for (
I = Refs.size() - 1;
I >= 0 && Refs[
I].isWriteOnly(); --
I)
86for (;
I >= 0 && Refs[
I].isReadOnly(); --
I)
88return {RORefCnt, WORefCnt};
95// Flags & 0x4 is reserved. DO NOT REUSE. 118assert(Flags <= 0x2ff &&
"Unexpected bits in flag");
119// 1 bit: WithGlobalValueDeadStripping flag. 120// Set on combined index only. 123// 1 bit: SkipModuleByDistributedBackend flag. 124// Set on combined index only. 127// Flags & 0x4 is reserved. DO NOT REUSE. 128// 1 bit: DisableSplitLTOUnit flag. 129// Set on per module indexes. It is up to the client to validate 130// the consistency of this flag across modules being linked. 133// 1 bit: PartiallySplitLTOUnits flag. 134// Set on combined index only. 137// 1 bit: WithAttributePropagation flag. 138// Set on combined index only. 141// 1 bit: WithDSOLocalPropagation flag. 142// Set on combined index only. 145// 1 bit: WithWholeProgramVisibility flag. 146// Set on combined index only. 149// 1 bit: WithSupportsHotColdNew flag. 150// Set on combined index only. 153// 1 bit: WithUnifiedLTO flag. 154// Set on combined index only. 159// Collect for the given module the list of function it defines 163for (
auto &GlobalList : *
this) {
164auto GUID = GlobalList.first;
165for (
auto &GlobSummary : GlobalList.second.SummaryList) {
166auto *Summary = dyn_cast_or_null<FunctionSummary>(GlobSummary.get());
168// Ignore global variable, focus on functions 170// Ignore summaries from other modules. 171if (Summary->modulePath() != ModulePath)
173 GVSummaryMap[GUID] = Summary;
180bool PerModuleIndex)
const{
182assert(VI &&
"GlobalValue not found in index");
183assert((!PerModuleIndex || VI.getSummaryList().size() == 1) &&
184"Expected a single entry per global value in per-module index");
185auto &Summary = VI.getSummaryList()[0];
193constauto &SummaryList = VI.getSummaryList();
194if (SummaryList.empty())
196for (
auto &
I : SummaryList)
205// If reference is not readonly or writeonly then referenced summary is not 206// read/writeonly either. Note that: 207// - All references from GlobalVarSummary are conservatively considered as 208// not readonly or writeonly. Tracking them properly requires more complex 209// analysis then we have now. 211// - AliasSummary objects have no refs at all so this function is a no-op 213for (
auto &VI : S->
refs()) {
214assert(VI.getAccessSpecifier() == 0 || isa<FunctionSummary>(S));
215if (!VI.getAccessSpecifier()) {
216if (!MarkedNonReadWriteOnly.
insert(VI).second)
218 }
elseif (MarkedNonReadWriteOnly.
contains(VI))
220for (
auto &
Ref : VI.getSummaryList())
221// If references to alias is not read/writeonly then aliasee 222// is not read/writeonly 223if (
auto *GVS = dyn_cast<GlobalVarSummary>(
Ref->getBaseObject())) {
225 GVS->setReadOnly(
false);
226if (!VI.isWriteOnly())
227 GVS->setWriteOnly(
false);
232// Do the access attribute and DSOLocal propagation in combined index. 233// The goal of attribute propagation is internalization of readonly (RO) 234// or writeonly (WO) variables. To determine which variables are RO or WO 235// and which are not we take following steps: 236// - During analysis we speculatively assign readonly and writeonly 237// attribute to all variables which can be internalized. When computing 238// function summary we also assign readonly or writeonly attribute to a 239// reference if function doesn't modify referenced variable (readonly) 240// or doesn't read it (writeonly). 242// - After computing dead symbols in combined index we do the attribute 243// and DSOLocal propagation. During this step we: 244// a. clear RO and WO attributes from variables which are preserved or 246// b. clear RO and WO attributes from variables referenced by any global 247// variable initializer 248// c. clear RO attribute from variable referenced by a function when 249// reference is not readonly 250// d. clear WO attribute from variable referenced by a function when 251// reference is not writeonly 252// e. clear IsDSOLocal flag in every summary if any of them is false. 254// Because of (c, d) we don't internalize variables read by function A 255// and modified by function B. 257// Internalization itself happens in the backend after import is finished 258// See internalizeGVsAfterImport. 264for (
auto &
P : *
this) {
265bool IsDSOLocal =
true;
266for (
auto &S :
P.second.SummaryList) {
268// computeDeadSymbolsAndUpdateIndirectCalls should have marked all 269// copies live. Note that it is possible that there is a GUID collision 270// between internal symbols with the same name in different files of the 271// same name but not enough distinguishing path. Because 272// computeDeadSymbolsAndUpdateIndirectCalls should conservatively mark 273// all copies live we can assert here that all are dead if any copy is 277 [&](
const std::unique_ptr<GlobalValueSummary> &Summary) {
278 return isGlobalValueLive(Summary.get());
280// We don't examine references from dead objects 284// Global variable can't be marked read/writeonly if it is not eligible 285// to import since we need to ensure that all external references get 286// a local (imported) copy. It also can't be marked read/writeonly if 287// it or any alias (since alias points to the same memory) are preserved 288// or notEligibleToImport, since either of those means there could be 289// writes (or reads in case of writeonly) that are not visible (because 290// preserved means it could have external to DSO writes or reads, and 291// notEligibleToImport means it could have writes or reads via inline 292// assembly leading it to be in the @llvm.*used). 293if (
auto *GVS = dyn_cast<GlobalVarSummary>(S->getBaseObject()))
294// Here we intentionally pass S.get() not GVS, because S could be 295// an alias. We don't analyze references here, because we have to 296// know exactly if GV is readonly to do so. 298 GUIDPreservedSymbols.
count(
P.first)) {
299 GVS->setReadOnly(
false);
300 GVS->setWriteOnly(
false);
304// If the flag from any summary is false, the GV is not DSOLocal. 305 IsDSOLocal &= S->isDSOLocal();
308// Mark the flag in all summaries false so that we can do quick check 309// without going through the whole list. 310for (
const std::unique_ptr<GlobalValueSummary> &Summary :
312 Summary->setDSOLocal(
false);
318if (
P.second.SummaryList.size())
319if (
auto *GVS = dyn_cast<GlobalVarSummary>(
320P.second.SummaryList[0]->getBaseObject()))
322if (GVS->maybeReadOnly())
324if (GVS->maybeWriteOnly())
325 WriteOnlyLiveGVars++;
330bool AnalyzeRefs)
const{
337bool &CanImportDecl)
const{
339// We don't analyze GV references during attribute propagation, so 340// GV with non-trivial initializer can be marked either read or 342// Importing definiton of readonly GV with non-trivial initializer 343// allows us doing some extra optimizations (like converting indirect 345// Definition of writeonly GV with non-trivial initializer should also 346// be imported. Not doing so will result in: 347// a) GV internalization in source module (because it's writeonly) 348// b) Importing of GV declaration to destination module as a result 350// c) Link error (external declaration with internal definition). 351// However we do not promote objects referenced by writeonly GV 352// initializer by means of converting it to 'zeroinitializer' 358constbool nonInterposable =
362// It's correct to import a global variable only when it is not interposable 363// and eligible to import. 364 CanImportDecl = (nonInterposable && eligibleToImport);
366// Global variable with non-trivial initializer can be imported 367// if it's readonly. This gives us extra opportunities for constant 368// folding and converting indirect calls to direct calls. We don't 369// analyze GV references during attribute propagation, because we 370// don't know yet if it is readonly or not. 371return nonInterposable && eligibleToImport &&
372 (!AnalyzeRefs || !HasRefsPreventingImport(GVS));
375// TODO: write a graphviz dumper for SCCs (see ModuleSummaryIndex::exportToDot) 376// then delete this function and update its tests 380 scc_begin<ModuleSummaryIndex *>(
this);
382 O <<
"SCC (" << utostr(
I->size()) <<
" node" << (
I->size() == 1 ?
"" :
"s")
386if (V.getSummaryList().size())
387F = cast<FunctionSummary>(V.getSummaryList().front().get());
388 O <<
" " << (
F ==
nullptr ?
"External" :
"") <<
" " << utostr(V.getGUID())
389 << (
I.hasCycle() ?
" (has cycle)" :
"") <<
"\n";
399void addComment(
constTwine &Comment);
400 std::string getAsString()
const;
402 std::vector<std::string> Attrs;
403 std::string Comments;
415constTwine &Comment) {
416 std::string
A =
Name.str();
424void Attributes::addComment(
constTwine &Comment) {
425if (!
Comment.isTriviallyEmpty()) {
434std::string Attributes::getAsString()
const{
477auto FlagValue = [](
unsigned V) {
return V ?
'1' :
'0'; };
478char FlagRep[] = {FlagValue(
F.ReadNone),
479 FlagValue(
F.ReadOnly),
480 FlagValue(
F.NoRecurse),
481 FlagValue(
F.ReturnDoesNotAlias),
482 FlagValue(
F.NoInline),
483 FlagValue(
F.AlwaysInline),
484 FlagValue(
F.NoUnwind),
485 FlagValue(
F.MayThrow),
486 FlagValue(
F.HasUnknownCall),
487 FlagValue(
F.MustBeUnreachable),
493// Get string representation of function instruction count and flags. 495auto *FS = dyn_cast_or_null<FunctionSummary>(GVS);
499return std::string(
"inst: ") + std::to_string(FS->instCount()) +
504return std::string(
"@") + std::to_string(Id);
512if (isa<AliasSummary>(GVS))
519 Label += std::string(
" (") + Attrs +
")";
525// Write definition of external node, which doesn't have any 526// specific module associated with it. Typically this is function 527// or variable defined in native object or library. 530auto StrId = std::to_string(Id);
531OS <<
" " << StrId <<
" [label=\"";
538OS <<
"\"]; // defined externally\n";
542if (
auto *GVS = dyn_cast<GlobalVarSummary>(S))
543return GVS->maybeReadOnly();
548if (
auto *GVS = dyn_cast<GlobalVarSummary>(S))
549return GVS->maybeWriteOnly();
554if (
auto *GVS = dyn_cast<GlobalVarSummary>(S))
555return GVS->isConstant();
562 std::vector<Edge> CrossModuleEdges;
564usingGVSOrderedMapTy = std::map<GlobalValue::GUID, GlobalValueSummary *>;
565 std::map<StringRef, GVSOrderedMapTy> ModuleToDefinedGVS;
568// Assign an id to each module path for use in graph labels. Since the 569// StringMap iteration order isn't guaranteed, order by path string before 571 std::vector<StringRef> ModulePaths;
573 ModulePaths.push_back(ModPath);
576for (
auto &ModPath : ModulePaths)
579// Get node identifier in form MXXX_<GUID>. The MXXX prefix is required, 580// because we may have multiple linkonce functions summaries. 582return ModId == (
uint64_t)-1 ? std::to_string(Id)
583 : std::string(
"M") + std::to_string(ModId) +
584"_" + std::to_string(Id);
592// 2 - constant reference 593// 3 - writeonly reference 594// Other value: (hotness - 4). 596staticconstchar *EdgeAttrs[] = {
597" [style=dotted]; // alias",
598" [style=dashed]; // ref",
599" [style=dashed,color=forestgreen]; // const-ref",
600" [style=dashed,color=violetred]; // writeOnly-ref",
601" // call (hotness : Unknown)",
602" [color=blue]; // call (hotness : Cold)",
603" // call (hotness : None)",
604" [color=brown]; // call (hotness : Hot)",
605" [style=bold,color=red]; // call (hotness : Critical)"};
607assert(
static_cast<size_t>(TypeOrHotness) < std::size(EdgeAttrs));
608OS << Pfx << NodeId(SrcMod, SrcId) <<
" -> " << NodeId(DstMod, DstId)
609 << EdgeAttrs[TypeOrHotness] <<
"\n";
612OS <<
"digraph Summary {\n";
613for (
auto &ModIt : ModuleToDefinedGVS) {
614// Will be empty for a just built per-module index, which doesn't setup a 615// module paths table. In that case use 0 as the module id. 617auto ModId = ModuleIdMap.
empty() ? 0 : ModuleIdMap[ModIt.first];
618OS <<
" // Module: " << ModIt.first <<
"\n";
619OS <<
" subgraph cluster_" << std::to_string(ModId) <<
" {\n";
620OS <<
" style = filled;\n";
621OS <<
" color = lightgrey;\n";
623OS <<
" node [style=filled,fillcolor=lightblue];\n";
625auto &GVSMap = ModIt.second;
627if (!GVSMap.count(IdTo)) {
628 CrossModuleEdges.push_back({ModId, Hotness, IdFrom, IdTo});
631 DrawEdge(
" ", ModId, IdFrom, ModId, IdTo, Hotness);
634for (
auto &SummaryIt : GVSMap) {
635 NodeMap[SummaryIt.first].push_back(ModId);
636auto Flags = SummaryIt.second->flags();
638if (isa<FunctionSummary>(SummaryIt.second)) {
639A.add(
"shape",
"record",
"function");
640 }
elseif (isa<AliasSummary>(SummaryIt.second)) {
641A.add(
"style",
"dotted,filled",
"alias");
644A.add(
"shape",
"Mrecord",
"variable");
646A.addComment(
"immutable");
648A.addComment(
"writeOnly");
650A.addComment(
"constant");
653A.addComment(
"visibility");
655A.addComment(
"dsoLocal");
656if (Flags.CanAutoHide)
657A.addComment(
"canAutoHide");
659A.addComment(
"definition");
661A.addComment(
"declaration");
662if (GUIDPreservedSymbols.
count(SummaryIt.first))
663A.addComment(
"preserved");
668A.add(
"fillcolor",
"red",
"dead");
669elseif (Flags.NotEligibleToImport)
670A.add(
"fillcolor",
"yellow",
"not eligible to import");
672OS <<
" " << NodeId(ModId, SummaryIt.first) <<
" " <<
A.getAsString()
677for (
auto &SummaryIt : GVSMap) {
678auto *GVS = SummaryIt.second;
679for (
auto &R : GVS->refs())
680 Draw(SummaryIt.first, R.getGUID(),
681 R.isWriteOnly() ? -1 : (R.isReadOnly() ? -2 : -3));
683if (
auto *AS = dyn_cast_or_null<AliasSummary>(SummaryIt.second)) {
684 Draw(SummaryIt.first, AS->getAliaseeGUID(), -4);
688if (
auto *FS = dyn_cast_or_null<FunctionSummary>(SummaryIt.second))
689for (
auto &CGEdge : FS->calls())
690 Draw(SummaryIt.first, CGEdge.first.getGUID(),
691static_cast<int>(CGEdge.second.Hotness));
696OS <<
" // Cross-module edges:\n";
697for (
auto &E : CrossModuleEdges) {
698auto &ModList = NodeMap[E.Dst];
699if (ModList.empty()) {
701// Add fake module to the list to draw an edge to an external node 703 ModList.push_back(-1);
705for (
auto DstMod : ModList)
706// The edge representing call or ref is drawn to every module where target 707// symbol is defined. When target is a linkonce symbol there can be 708// multiple edges representing a single call or ref, both intra-module and 709// cross-module. As we've already drawn all intra-module edges before we 711if (DstMod != E.SrcMod)
712 DrawEdge(
" ", E.SrcMod, E.Src, DstMod, E.Dst, E.Hotness);
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
static std::string getNodeVisualName(GlobalValue::GUID Id)
static std::string getNodeLabel(const ValueInfo &VI, GlobalValueSummary *GVS)
static std::string getSummaryAttributes(GlobalValueSummary *GVS)
static cl::opt< bool > ImportConstantsWithRefs("import-constants-with-refs", cl::init(true), cl::Hidden, cl::desc("Import constant global variables with references"))
static std::string fflagsToString(FunctionSummary::FFlags F)
static bool hasWriteOnlyFlag(const GlobalValueSummary *S)
static void propagateAttributesToRefs(GlobalValueSummary *S, DenseSet< ValueInfo > &MarkedNonReadWriteOnly)
static std::string linkageToString(GlobalValue::LinkageTypes LT)
static void defineExternalNode(raw_ostream &OS, const char *Pfx, const ValueInfo &VI, GlobalValue::GUID Id)
static cl::opt< bool > PropagateAttrs("propagate-attrs", cl::init(true), cl::Hidden, cl::desc("Propagate attributes in index"))
static bool hasReadOnlyFlag(const GlobalValueSummary *S)
static bool hasConstantFlag(const GlobalValueSummary *S)
ModuleSummaryIndex.h This file contains the declarations the classes that hold the module index and s...
This builds on the llvm/ADT/GraphTraits.h file to find the strongly connected components (SCCs) of a ...
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
std::pair< iterator, bool > try_emplace(KeyT &&Key, Ts &&...Args)
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
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.
static FunctionSummary makeDummyFunctionSummary(SmallVectorImpl< FunctionSummary::EdgeTy > &&Edges)
Create an empty FunctionSummary (with specified call edges).
std::pair< unsigned, unsigned > specialRefCounts() const
Function and variable summary information to aid decisions and implementation of importing.
GlobalValueSummary * getBaseObject()
If this is an alias summary, returns the summary of the aliased object (a global variable or function...
ArrayRef< ValueInfo > refs() const
Return the list of values referenced by this global value definition.
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.
uint64_t GUID
Declare a type to represent a global unique identifier for a global value.
VisibilityTypes
An enumeration for the kinds of visibility of global values.
@ DefaultVisibility
The GV is visible.
@ HiddenVisibility
The GV is hidden.
@ ProtectedVisibility
The GV is protected.
static bool isInterposableLinkage(LinkageTypes Linkage)
Whether the definition of this global may be replaced by something non-equivalent at link time.
LinkageTypes
An enumeration for the kinds of linkage for global values.
@ PrivateLinkage
Like Internal, but omit from symbol table.
@ CommonLinkage
Tentative definitions.
@ InternalLinkage
Rename collisions when linking (static functions).
@ LinkOnceAnyLinkage
Keep one copy of function when linking (inline)
@ WeakODRLinkage
Same, but only replaced by something equivalent.
@ ExternalLinkage
Externally visible function.
@ WeakAnyLinkage
Keep one copy of named function when linking (weak)
@ AppendingLinkage
Special purpose, only applies to global arrays.
@ AvailableExternallyLinkage
Available for inspection, not emission.
@ ExternalWeakLinkage
ExternalWeak linkage description.
@ LinkOnceODRLinkage
Same, but only replaced by something equivalent.
Global variable summary information to aid decisions and implementation of importing.
bool withAttributePropagation() const
bool withGlobalValueDeadStripping() const
bool withWholeProgramVisibility() const
bool isGUIDLive(GlobalValue::GUID GUID) const
bool isReadOnly(const GlobalVarSummary *GVS) const
void setFlags(uint64_t Flags)
bool isWriteOnly(const GlobalVarSummary *GVS) const
void setPartiallySplitLTOUnits()
ValueInfo getValueInfo(const GlobalValueSummaryMapTy::value_type &R) const
Return a ValueInfo for the index value_type (convenient when iterating index).
void setEnableSplitLTOUnit()
bool partiallySplitLTOUnits() const
void collectDefinedFunctionsForModule(StringRef ModulePath, GVSummaryMapTy &GVSummaryMap) const
Collect for the given module the list of functions it defines (GUID -> Summary).
void dumpSCCs(raw_ostream &OS)
Print out strongly connected components for debugging.
bool isGlobalValueLive(const GlobalValueSummary *GVS) const
bool enableSplitLTOUnit() const
void setWithSupportsHotColdNew()
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 collectDefinedGVSummariesPerModule(Map &ModuleToDefinedGVSummaries) const
Collect for each module the list of Summaries it defines (GUID -> Summary).
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
void setWithDSOLocalPropagation()
bool skipModuleByDistributedBackend() const
uint64_t getFlags() const
GlobalValueSummary * getGlobalValueSummary(const GlobalValue &GV, bool PerModuleIndex=true) const
Returns the first GlobalValueSummary for GV, asserting that there is only one if PerModuleIndex.
void setWithGlobalValueDeadStripping()
void setWithWholeProgramVisibility()
bool canImportGlobalVar(const GlobalValueSummary *S, bool AnalyzeRefs) const
Checks if we can import global variable from another module.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
LLVM Value Representation.
std::pair< iterator, bool > insert(const ValueT &V)
bool contains(const_arg_type_t< ValueT > V) const
Check if the set contains the given element.
size_type count(const_arg_type_t< ValueT > V) const
Return 1 if the specified key is in the set, 0 otherwise.
This class implements an extremely fast bulk output stream that can only output to a stream.
Enumerate the SCCs of a directed graph in reverse topological order of the SCC DAG.
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
initializer< Ty > init(const Ty &Val)
StringRef filename(StringRef path LLVM_LIFETIME_BOUND, Style style=Style::native)
Get filename.
This is an optimization pass for GlobalISel generic memory operations.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
iterator_range< pointee_iterator< WrappedIteratorT > > make_pointee_range(RangeT &&Range)
void sort(IteratorTy Start, IteratorTy End)
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly.
bool AreStatisticsEnabled()
Check if statistics are enabled.
@ Ref
The access may reference the value stored in memory.
Flags specific to function summaries.
static constexpr uint32_t RangeWidth
Struct that holds a reference to a particular GUID in a global value summary.
GlobalValue::VisibilityTypes getELFVisibility() const
Returns the most constraining visibility among summaries.
ArrayRef< std::unique_ptr< GlobalValueSummary > > getSummaryList() const
bool canAutoHide() const
Checks if all copies are eligible for auto-hiding (have flag set).
bool isDSOLocal(bool WithDSOLocalPropagation=false) const
Checks if all summaries are DSO local (have the flag set).
