LLVM  14.0.0git
ModuleSummaryIndex.cpp
Go to the documentation of this file.
1 //===-- ModuleSummaryIndex.cpp - Module Summary Index ---------------------===//
2 //
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
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the module index and summary classes for the
10 // IR library.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "llvm/ADT/SCCIterator.h"
16 #include "llvm/ADT/Statistic.h"
17 #include "llvm/ADT/StringMap.h"
19 #include "llvm/Support/Path.h"
21 using namespace llvm;
22 
23 #define DEBUG_TYPE "module-summary-index"
24 
25 STATISTIC(ReadOnlyLiveGVars,
26  "Number of live global variables marked read only");
27 STATISTIC(WriteOnlyLiveGVars,
28  "Number of live global variables marked write only");
29 
30 static cl::opt<bool> PropagateAttrs("propagate-attrs", cl::init(true),
31  cl::Hidden,
32  cl::desc("Propagate attributes in index"));
33 
35  "import-constants-with-refs", cl::init(true), cl::Hidden,
36  cl::desc("Import constant global variables with references"));
37 
39 
42 
44  bool HasProtected = false;
45  for (const auto &S : make_pointee_range(getSummaryList())) {
46  if (S.getVisibility() == GlobalValue::HiddenVisibility)
48  if (S.getVisibility() == GlobalValue::ProtectedVisibility)
49  HasProtected = true;
50  }
51  return HasProtected ? GlobalValue::ProtectedVisibility
53 }
54 
55 bool ValueInfo::isDSOLocal(bool WithDSOLocalPropagation) const {
56  // With DSOLocal propagation done, the flag in evey summary is the same.
57  // Check the first one is enough.
58  return WithDSOLocalPropagation
59  ? getSummaryList().size() && getSummaryList()[0]->isDSOLocal()
60  : getSummaryList().size() &&
63  [](const std::unique_ptr<GlobalValueSummary> &Summary) {
64  return Summary->isDSOLocal();
65  });
66 }
67 
68 bool ValueInfo::canAutoHide() const {
69  // Can only auto hide if all copies are eligible to auto hide.
70  return getSummaryList().size() &&
72  [](const std::unique_ptr<GlobalValueSummary> &Summary) {
73  return Summary->canAutoHide();
74  });
75 }
76 
77 // Gets the number of readonly and writeonly refs in RefEdgeList
78 std::pair<unsigned, unsigned> FunctionSummary::specialRefCounts() const {
79  // Here we take advantage of having all readonly and writeonly references
80  // located in the end of the RefEdgeList.
81  auto Refs = refs();
82  unsigned RORefCnt = 0, WORefCnt = 0;
83  int I;
84  for (I = Refs.size() - 1; I >= 0 && Refs[I].isWriteOnly(); --I)
85  WORefCnt++;
86  for (; I >= 0 && Refs[I].isReadOnly(); --I)
87  RORefCnt++;
88  return {RORefCnt, WORefCnt};
89 }
90 
92 
94  uint64_t Flags = 0;
96  Flags |= 0x1;
98  Flags |= 0x2;
100  Flags |= 0x4;
101  if (enableSplitLTOUnit())
102  Flags |= 0x8;
104  Flags |= 0x10;
106  Flags |= 0x20;
108  Flags |= 0x40;
109  return Flags;
110 }
111 
113  assert(Flags <= 0x7f && "Unexpected bits in flag");
114  // 1 bit: WithGlobalValueDeadStripping flag.
115  // Set on combined index only.
116  if (Flags & 0x1)
118  // 1 bit: SkipModuleByDistributedBackend flag.
119  // Set on combined index only.
120  if (Flags & 0x2)
122  // 1 bit: HasSyntheticEntryCounts flag.
123  // Set on combined index only.
124  if (Flags & 0x4)
126  // 1 bit: DisableSplitLTOUnit flag.
127  // Set on per module indexes. It is up to the client to validate
128  // the consistency of this flag across modules being linked.
129  if (Flags & 0x8)
131  // 1 bit: PartiallySplitLTOUnits flag.
132  // Set on combined index only.
133  if (Flags & 0x10)
135  // 1 bit: WithAttributePropagation flag.
136  // Set on combined index only.
137  if (Flags & 0x20)
139  // 1 bit: WithDSOLocalPropagation flag.
140  // Set on combined index only.
141  if (Flags & 0x40)
143 }
144 
145 // Collect for the given module the list of function it defines
146 // (GUID -> Summary).
148  StringRef ModulePath, GVSummaryMapTy &GVSummaryMap) const {
149  for (auto &GlobalList : *this) {
150  auto GUID = GlobalList.first;
151  for (auto &GlobSummary : GlobalList.second.SummaryList) {
152  auto *Summary = dyn_cast_or_null<FunctionSummary>(GlobSummary.get());
153  if (!Summary)
154  // Ignore global variable, focus on functions
155  continue;
156  // Ignore summaries from other modules.
157  if (Summary->modulePath() != ModulePath)
158  continue;
159  GVSummaryMap[GUID] = Summary;
160  }
161  }
162 }
163 
166  bool PerModuleIndex) const {
167  auto VI = getValueInfo(ValueGUID);
168  assert(VI && "GlobalValue not found in index");
169  assert((!PerModuleIndex || VI.getSummaryList().size() == 1) &&
170  "Expected a single entry per global value in per-module index");
171  auto &Summary = VI.getSummaryList()[0];
172  return Summary.get();
173 }
174 
176  auto VI = getValueInfo(GUID);
177  if (!VI)
178  return true;
179  const auto &SummaryList = VI.getSummaryList();
180  if (SummaryList.empty())
181  return true;
182  for (auto &I : SummaryList)
183  if (isGlobalValueLive(I.get()))
184  return true;
185  return false;
186 }
187 
188 static void
190  DenseSet<ValueInfo> &MarkedNonReadWriteOnly) {
191  // If reference is not readonly or writeonly then referenced summary is not
192  // read/writeonly either. Note that:
193  // - All references from GlobalVarSummary are conservatively considered as
194  // not readonly or writeonly. Tracking them properly requires more complex
195  // analysis then we have now.
196  //
197  // - AliasSummary objects have no refs at all so this function is a no-op
198  // for them.
199  for (auto &VI : S->refs()) {
200  assert(VI.getAccessSpecifier() == 0 || isa<FunctionSummary>(S));
201  if (!VI.getAccessSpecifier()) {
202  if (!MarkedNonReadWriteOnly.insert(VI).second)
203  continue;
204  } else if (MarkedNonReadWriteOnly.contains(VI))
205  continue;
206  for (auto &Ref : VI.getSummaryList())
207  // If references to alias is not read/writeonly then aliasee
208  // is not read/writeonly
209  if (auto *GVS = dyn_cast<GlobalVarSummary>(Ref->getBaseObject())) {
210  if (!VI.isReadOnly())
211  GVS->setReadOnly(false);
212  if (!VI.isWriteOnly())
213  GVS->setWriteOnly(false);
214  }
215  }
216 }
217 
218 // Do the access attribute and DSOLocal propagation in combined index.
219 // The goal of attribute propagation is internalization of readonly (RO)
220 // or writeonly (WO) variables. To determine which variables are RO or WO
221 // and which are not we take following steps:
222 // - During analysis we speculatively assign readonly and writeonly
223 // attribute to all variables which can be internalized. When computing
224 // function summary we also assign readonly or writeonly attribute to a
225 // reference if function doesn't modify referenced variable (readonly)
226 // or doesn't read it (writeonly).
227 //
228 // - After computing dead symbols in combined index we do the attribute
229 // and DSOLocal propagation. During this step we:
230 // a. clear RO and WO attributes from variables which are preserved or
231 // can't be imported
232 // b. clear RO and WO attributes from variables referenced by any global
233 // variable initializer
234 // c. clear RO attribute from variable referenced by a function when
235 // reference is not readonly
236 // d. clear WO attribute from variable referenced by a function when
237 // reference is not writeonly
238 // e. clear IsDSOLocal flag in every summary if any of them is false.
239 //
240 // Because of (c, d) we don't internalize variables read by function A
241 // and modified by function B.
242 //
243 // Internalization itself happens in the backend after import is finished
244 // See internalizeGVsAfterImport.
246  const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols) {
247  if (!PropagateAttrs)
248  return;
249  DenseSet<ValueInfo> MarkedNonReadWriteOnly;
250  for (auto &P : *this) {
251  bool IsDSOLocal = true;
252  for (auto &S : P.second.SummaryList) {
253  if (!isGlobalValueLive(S.get())) {
254  // computeDeadSymbols should have marked all copies live. Note that
255  // it is possible that there is a GUID collision between internal
256  // symbols with the same name in different files of the same name but
257  // not enough distinguishing path. Because computeDeadSymbols should
258  // conservatively mark all copies live we can assert here that all are
259  // dead if any copy is dead.
261  P.second.SummaryList,
262  [&](const std::unique_ptr<GlobalValueSummary> &Summary) {
263  return isGlobalValueLive(Summary.get());
264  }));
265  // We don't examine references from dead objects
266  break;
267  }
268 
269  // Global variable can't be marked read/writeonly if it is not eligible
270  // to import since we need to ensure that all external references get
271  // a local (imported) copy. It also can't be marked read/writeonly if
272  // it or any alias (since alias points to the same memory) are preserved
273  // or notEligibleToImport, since either of those means there could be
274  // writes (or reads in case of writeonly) that are not visible (because
275  // preserved means it could have external to DSO writes or reads, and
276  // notEligibleToImport means it could have writes or reads via inline
277  // assembly leading it to be in the @llvm.*used).
278  if (auto *GVS = dyn_cast<GlobalVarSummary>(S->getBaseObject()))
279  // Here we intentionally pass S.get() not GVS, because S could be
280  // an alias. We don't analyze references here, because we have to
281  // know exactly if GV is readonly to do so.
282  if (!canImportGlobalVar(S.get(), /* AnalyzeRefs */ false) ||
283  GUIDPreservedSymbols.count(P.first)) {
284  GVS->setReadOnly(false);
285  GVS->setWriteOnly(false);
286  }
287  propagateAttributesToRefs(S.get(), MarkedNonReadWriteOnly);
288 
289  // If the flag from any summary is false, the GV is not DSOLocal.
290  IsDSOLocal &= S->isDSOLocal();
291  }
292  if (!IsDSOLocal)
293  // Mark the flag in all summaries false so that we can do quick check
294  // without going through the whole list.
295  for (const std::unique_ptr<GlobalValueSummary> &Summary :
296  P.second.SummaryList)
297  Summary->setDSOLocal(false);
298  }
302  for (auto &P : *this)
303  if (P.second.SummaryList.size())
304  if (auto *GVS = dyn_cast<GlobalVarSummary>(
305  P.second.SummaryList[0]->getBaseObject()))
306  if (isGlobalValueLive(GVS)) {
307  if (GVS->maybeReadOnly())
308  ReadOnlyLiveGVars++;
309  if (GVS->maybeWriteOnly())
310  WriteOnlyLiveGVars++;
311  }
312 }
313 
315  bool AnalyzeRefs) const {
316  auto HasRefsPreventingImport = [this](const GlobalVarSummary *GVS) {
317  // We don't analyze GV references during attribute propagation, so
318  // GV with non-trivial initializer can be marked either read or
319  // write-only.
320  // Importing definiton of readonly GV with non-trivial initializer
321  // allows us doing some extra optimizations (like converting indirect
322  // calls to direct).
323  // Definition of writeonly GV with non-trivial initializer should also
324  // be imported. Not doing so will result in:
325  // a) GV internalization in source module (because it's writeonly)
326  // b) Importing of GV declaration to destination module as a result
327  // of promotion.
328  // c) Link error (external declaration with internal definition).
329  // However we do not promote objects referenced by writeonly GV
330  // initializer by means of converting it to 'zeroinitializer'
331  return !(ImportConstantsWithRefs && GVS->isConstant()) &&
332  !isReadOnly(GVS) && !isWriteOnly(GVS) && GVS->refs().size();
333  };
334  auto *GVS = cast<GlobalVarSummary>(S->getBaseObject());
335 
336  // Global variable with non-trivial initializer can be imported
337  // if it's readonly. This gives us extra opportunities for constant
338  // folding and converting indirect calls to direct calls. We don't
339  // analyze GV references during attribute propagation, because we
340  // don't know yet if it is readonly or not.
341  return !GlobalValue::isInterposableLinkage(S->linkage()) &&
342  !S->notEligibleToImport() &&
343  (!AnalyzeRefs || !HasRefsPreventingImport(GVS));
344 }
345 
346 // TODO: write a graphviz dumper for SCCs (see ModuleSummaryIndex::exportToDot)
347 // then delete this function and update its tests
351  scc_begin<ModuleSummaryIndex *>(this);
352  !I.isAtEnd(); ++I) {
353  O << "SCC (" << utostr(I->size()) << " node" << (I->size() == 1 ? "" : "s")
354  << ") {\n";
355  for (const ValueInfo &V : *I) {
356  FunctionSummary *F = nullptr;
357  if (V.getSummaryList().size())
358  F = cast<FunctionSummary>(V.getSummaryList().front().get());
359  O << " " << (F == nullptr ? "External" : "") << " " << utostr(V.getGUID())
360  << (I.hasCycle() ? " (has cycle)" : "") << "\n";
361  }
362  O << "}\n";
363  }
364 }
365 
366 namespace {
367 struct Attributes {
368  void add(const Twine &Name, const Twine &Value,
369  const Twine &Comment = Twine());
370  void addComment(const Twine &Comment);
371  std::string getAsString() const;
372 
373  std::vector<std::string> Attrs;
374  std::string Comments;
375 };
376 
377 struct Edge {
378  uint64_t SrcMod;
379  int Hotness;
380  GlobalValue::GUID Src;
381  GlobalValue::GUID Dst;
382 };
383 }
384 
385 void Attributes::add(const Twine &Name, const Twine &Value,
386  const Twine &Comment) {
387  std::string A = Name.str();
388  A += "=\"";
389  A += Value.str();
390  A += "\"";
391  Attrs.push_back(A);
392  addComment(Comment);
393 }
394 
395 void Attributes::addComment(const Twine &Comment) {
396  if (!Comment.isTriviallyEmpty()) {
397  if (Comments.empty())
398  Comments = " // ";
399  else
400  Comments += ", ";
401  Comments += Comment.str();
402  }
403 }
404 
405 std::string Attributes::getAsString() const {
406  if (Attrs.empty())
407  return "";
408 
409  std::string Ret = "[";
410  for (auto &A : Attrs)
411  Ret += A + ",";
412  Ret.pop_back();
413  Ret += "];";
414  Ret += Comments;
415  return Ret;
416 }
417 
419  switch (LT) {
421  return "extern";
423  return "av_ext";
425  return "linkonce";
427  return "linkonce_odr";
429  return "weak";
431  return "weak_odr";
433  return "appending";
435  return "internal";
437  return "private";
439  return "extern_weak";
441  return "common";
442  }
443 
444  return "<unknown>";
445 }
446 
448  auto FlagValue = [](unsigned V) { return V ? '1' : '0'; };
449  char FlagRep[] = {FlagValue(F.ReadNone), FlagValue(F.ReadOnly),
450  FlagValue(F.NoRecurse), FlagValue(F.ReturnDoesNotAlias),
451  FlagValue(F.NoInline), FlagValue(F.AlwaysInline), 0};
452 
453  return FlagRep;
454 }
455 
456 // Get string representation of function instruction count and flags.
457 static std::string getSummaryAttributes(GlobalValueSummary* GVS) {
458  auto *FS = dyn_cast_or_null<FunctionSummary>(GVS);
459  if (!FS)
460  return "";
461 
462  return std::string("inst: ") + std::to_string(FS->instCount()) +
463  ", ffl: " + fflagsToString(FS->fflags());
464 }
465 
467  return std::string("@") + std::to_string(Id);
468 }
469 
470 static std::string getNodeVisualName(const ValueInfo &VI) {
471  return VI.name().empty() ? getNodeVisualName(VI.getGUID()) : VI.name().str();
472 }
473 
474 static std::string getNodeLabel(const ValueInfo &VI, GlobalValueSummary *GVS) {
475  if (isa<AliasSummary>(GVS))
476  return getNodeVisualName(VI);
477 
478  std::string Attrs = getSummaryAttributes(GVS);
479  std::string Label =
480  getNodeVisualName(VI) + "|" + linkageToString(GVS->linkage());
481  if (!Attrs.empty())
482  Label += std::string(" (") + Attrs + ")";
483  Label += "}";
484 
485  return Label;
486 }
487 
488 // Write definition of external node, which doesn't have any
489 // specific module associated with it. Typically this is function
490 // or variable defined in native object or library.
491 static void defineExternalNode(raw_ostream &OS, const char *Pfx,
492  const ValueInfo &VI, GlobalValue::GUID Id) {
493  auto StrId = std::to_string(Id);
494  OS << " " << StrId << " [label=\"";
495 
496  if (VI) {
497  OS << getNodeVisualName(VI);
498  } else {
499  OS << getNodeVisualName(Id);
500  }
501  OS << "\"]; // defined externally\n";
502 }
503 
504 static bool hasReadOnlyFlag(const GlobalValueSummary *S) {
505  if (auto *GVS = dyn_cast<GlobalVarSummary>(S))
506  return GVS->maybeReadOnly();
507  return false;
508 }
509 
510 static bool hasWriteOnlyFlag(const GlobalValueSummary *S) {
511  if (auto *GVS = dyn_cast<GlobalVarSummary>(S))
512  return GVS->maybeWriteOnly();
513  return false;
514 }
515 
516 static bool hasConstantFlag(const GlobalValueSummary *S) {
517  if (auto *GVS = dyn_cast<GlobalVarSummary>(S))
518  return GVS->isConstant();
519  return false;
520 }
521 
523  raw_ostream &OS,
524  const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols) const {
525  std::vector<Edge> CrossModuleEdges;
527  using GVSOrderedMapTy = std::map<GlobalValue::GUID, GlobalValueSummary *>;
528  std::map<StringRef, GVSOrderedMapTy> ModuleToDefinedGVS;
529  collectDefinedGVSummariesPerModule(ModuleToDefinedGVS);
530 
531  // Get node identifier in form MXXX_<GUID>. The MXXX prefix is required,
532  // because we may have multiple linkonce functions summaries.
533  auto NodeId = [](uint64_t ModId, GlobalValue::GUID Id) {
534  return ModId == (uint64_t)-1 ? std::to_string(Id)
535  : std::string("M") + std::to_string(ModId) +
536  "_" + std::to_string(Id);
537  };
538 
539  auto DrawEdge = [&](const char *Pfx, uint64_t SrcMod, GlobalValue::GUID SrcId,
540  uint64_t DstMod, GlobalValue::GUID DstId,
541  int TypeOrHotness) {
542  // 0 - alias
543  // 1 - reference
544  // 2 - constant reference
545  // 3 - writeonly reference
546  // Other value: (hotness - 4).
547  TypeOrHotness += 4;
548  static const char *EdgeAttrs[] = {
549  " [style=dotted]; // alias",
550  " [style=dashed]; // ref",
551  " [style=dashed,color=forestgreen]; // const-ref",
552  " [style=dashed,color=violetred]; // writeOnly-ref",
553  " // call (hotness : Unknown)",
554  " [color=blue]; // call (hotness : Cold)",
555  " // call (hotness : None)",
556  " [color=brown]; // call (hotness : Hot)",
557  " [style=bold,color=red]; // call (hotness : Critical)"};
558 
559  assert(static_cast<size_t>(TypeOrHotness) <
560  sizeof(EdgeAttrs) / sizeof(EdgeAttrs[0]));
561  OS << Pfx << NodeId(SrcMod, SrcId) << " -> " << NodeId(DstMod, DstId)
562  << EdgeAttrs[TypeOrHotness] << "\n";
563  };
564 
565  OS << "digraph Summary {\n";
566  for (auto &ModIt : ModuleToDefinedGVS) {
567  auto ModId = getModuleId(ModIt.first);
568  OS << " // Module: " << ModIt.first << "\n";
569  OS << " subgraph cluster_" << std::to_string(ModId) << " {\n";
570  OS << " style = filled;\n";
571  OS << " color = lightgrey;\n";
572  OS << " label = \"" << sys::path::filename(ModIt.first) << "\";\n";
573  OS << " node [style=filled,fillcolor=lightblue];\n";
574 
575  auto &GVSMap = ModIt.second;
576  auto Draw = [&](GlobalValue::GUID IdFrom, GlobalValue::GUID IdTo, int Hotness) {
577  if (!GVSMap.count(IdTo)) {
578  CrossModuleEdges.push_back({ModId, Hotness, IdFrom, IdTo});
579  return;
580  }
581  DrawEdge(" ", ModId, IdFrom, ModId, IdTo, Hotness);
582  };
583 
584  for (auto &SummaryIt : GVSMap) {
585  NodeMap[SummaryIt.first].push_back(ModId);
586  auto Flags = SummaryIt.second->flags();
587  Attributes A;
588  if (isa<FunctionSummary>(SummaryIt.second)) {
589  A.add("shape", "record", "function");
590  } else if (isa<AliasSummary>(SummaryIt.second)) {
591  A.add("style", "dotted,filled", "alias");
592  A.add("shape", "box");
593  } else {
594  A.add("shape", "Mrecord", "variable");
595  if (Flags.Live && hasReadOnlyFlag(SummaryIt.second))
596  A.addComment("immutable");
597  if (Flags.Live && hasWriteOnlyFlag(SummaryIt.second))
598  A.addComment("writeOnly");
599  if (Flags.Live && hasConstantFlag(SummaryIt.second))
600  A.addComment("constant");
601  }
602  if (Flags.Visibility)
603  A.addComment("visibility");
604  if (Flags.DSOLocal)
605  A.addComment("dsoLocal");
606  if (Flags.CanAutoHide)
607  A.addComment("canAutoHide");
608  if (GUIDPreservedSymbols.count(SummaryIt.first))
609  A.addComment("preserved");
610 
611  auto VI = getValueInfo(SummaryIt.first);
612  A.add("label", getNodeLabel(VI, SummaryIt.second));
613  if (!Flags.Live)
614  A.add("fillcolor", "red", "dead");
615  else if (Flags.NotEligibleToImport)
616  A.add("fillcolor", "yellow", "not eligible to import");
617 
618  OS << " " << NodeId(ModId, SummaryIt.first) << " " << A.getAsString()
619  << "\n";
620  }
621  OS << " // Edges:\n";
622 
623  for (auto &SummaryIt : GVSMap) {
624  auto *GVS = SummaryIt.second;
625  for (auto &R : GVS->refs())
626  Draw(SummaryIt.first, R.getGUID(),
627  R.isWriteOnly() ? -1 : (R.isReadOnly() ? -2 : -3));
628 
629  if (auto *AS = dyn_cast_or_null<AliasSummary>(SummaryIt.second)) {
630  Draw(SummaryIt.first, AS->getAliaseeGUID(), -4);
631  continue;
632  }
633 
634  if (auto *FS = dyn_cast_or_null<FunctionSummary>(SummaryIt.second))
635  for (auto &CGEdge : FS->calls())
636  Draw(SummaryIt.first, CGEdge.first.getGUID(),
637  static_cast<int>(CGEdge.second.Hotness));
638  }
639  OS << " }\n";
640  }
641 
642  OS << " // Cross-module edges:\n";
643  for (auto &E : CrossModuleEdges) {
644  auto &ModList = NodeMap[E.Dst];
645  if (ModList.empty()) {
646  defineExternalNode(OS, " ", getValueInfo(E.Dst), E.Dst);
647  // Add fake module to the list to draw an edge to an external node
648  // in the loop below.
649  ModList.push_back(-1);
650  }
651  for (auto DstMod : ModList)
652  // The edge representing call or ref is drawn to every module where target
653  // symbol is defined. When target is a linkonce symbol there can be
654  // multiple edges representing a single call or ref, both intra-module and
655  // cross-module. As we've already drawn all intra-module edges before we
656  // skip it here.
657  if (DstMod != E.SrcMod)
658  DrawEdge(" ", E.SrcMod, E.Src, DstMod, E.Dst, E.Hotness);
659  }
660 
661  OS << "}";
662 }
llvm::GlobalValue::GUID
uint64_t GUID
Declare a type to represent a global unique identifier for a global value.
Definition: GlobalValue.h:503
llvm::ValueInfo::getSummaryList
ArrayRef< std::unique_ptr< GlobalValueSummary > > getSummaryList() const
Definition: ModuleSummaryIndex.h:187
Attrs
Function Attrs
Definition: README_ALTIVEC.txt:215
llvm::ModuleSummaryIndex::hasSyntheticEntryCounts
bool hasSyntheticEntryCounts() const
Definition: ModuleSummaryIndex.h:1231
LLVM_DUMP_METHOD
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
Definition: Compiler.h:491
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::none_of
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1565
llvm::GlobalValue::LinkOnceAnyLinkage
@ LinkOnceAnyLinkage
Keep one copy of function when linking (inline)
Definition: GlobalValue.h:50
llvm::ModuleSummaryIndex::setPartiallySplitLTOUnits
void setPartiallySplitLTOUnits()
Definition: ModuleSummaryIndex.h:1245
llvm::ModuleSummaryIndex::isReadOnly
bool isReadOnly(const GlobalVarSummary *GVS) const
Definition: ModuleSummaryIndex.h:1224
SCCIterator.h
llvm::Function::empty
bool empty() const
Definition: Function.h:739
llvm::ModuleSummaryIndex::setEnableSplitLTOUnit
void setEnableSplitLTOUnit()
Definition: ModuleSummaryIndex.h:1242
llvm::GlobalValue::HiddenVisibility
@ HiddenVisibility
The GV is hidden.
Definition: GlobalValue.h:64
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::GlobalVarSummary
Global variable summary information to aid decisions and implementation of importing.
Definition: ModuleSummaryIndex.h:834
Statistic.h
Path.h
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:143
llvm::Twine::isTriviallyEmpty
bool isTriviallyEmpty() const
Check if this twine is trivially empty; a false return value does not necessarily mean the twine is e...
Definition: Twine.h:421
PropagateAttrs
static cl::opt< bool > PropagateAttrs("propagate-attrs", cl::init(true), cl::Hidden, cl::desc("Propagate attributes in index"))
llvm::GlobalValue::DefaultVisibility
@ DefaultVisibility
The GV is visible.
Definition: GlobalValue.h:63
llvm::ModuleSummaryIndex::isGlobalValueLive
bool isGlobalValueLive(const GlobalValueSummary *GVS) const
Definition: ModuleSummaryIndex.h:1249
llvm::MipsISD::Ret
@ Ret
Definition: MipsISelLowering.h:116
llvm::GlobalValue::LinkageTypes
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:47
llvm::ModuleSummaryIndex::propagateAttributes
void propagateAttributes(const DenseSet< GlobalValue::GUID > &PreservedSymbols)
Do the access attribute and DSOLocal propagation in combined index.
Definition: ModuleSummaryIndex.cpp:245
llvm::detail::DenseSetImpl< ValueT, DenseMap< ValueT, detail::DenseSetEmpty, DenseMapInfo< ValueT >, detail::DenseSetPair< ValueT > >, DenseMapInfo< ValueT > >::insert
std::pair< iterator, bool > insert(const ValueT &V)
Definition: DenseSet.h:206
llvm::detail::DenseSetImpl< ValueT, DenseMap< ValueT, detail::DenseSetEmpty, DenseMapInfo< ValueT >, detail::DenseSetPair< ValueT > >, DenseMapInfo< ValueT > >::count
size_type count(const_arg_type_t< ValueT > V) const
Return 1 if the specified key is in the set, 0 otherwise.
Definition: DenseSet.h:97
llvm::ModuleSummaryIndex::getModuleId
uint64_t getModuleId(const StringRef ModPath) const
Get the module ID recorded for the given module path.
Definition: ModuleSummaryIndex.h:1389
ModuleSummaryIndex.h
llvm::ValueInfo::isDSOLocal
bool isDSOLocal(bool WithDSOLocalPropagation=false) const
Checks if all summaries are DSO local (have the flag set).
Definition: ModuleSummaryIndex.cpp:55
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::GlobalValueSummary::refs
ArrayRef< ValueInfo > refs() const
Return the list of values referenced by this global value definition.
Definition: ModuleSummaryIndex.h:438
getSummaryAttributes
static std::string getSummaryAttributes(GlobalValueSummary *GVS)
Definition: ModuleSummaryIndex.cpp:457
llvm::ModuleSummaryIndex::withDSOLocalPropagation
bool withDSOLocalPropagation() const
Definition: ModuleSummaryIndex.h:1221
llvm::AArch64CC::LT
@ LT
Definition: AArch64BaseInfo.h:266
CommandLine.h
llvm::ModuleSummaryIndex::setWithAttributePropagation
void setWithAttributePropagation()
Definition: ModuleSummaryIndex.h:1217
llvm::GlobalValueSummary
Function and variable summary information to aid decisions and implementation of importing.
Definition: ModuleSummaryIndex.h:290
llvm::all_of
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1551
hasReadOnlyFlag
static bool hasReadOnlyFlag(const GlobalValueSummary *S)
Definition: ModuleSummaryIndex.cpp:504
llvm::AreStatisticsEnabled
bool AreStatisticsEnabled()
Check if statistics are enabled.
Definition: Statistic.cpp:138
llvm::GlobalValue::VisibilityTypes
VisibilityTypes
An enumeration for the kinds of visibility of global values.
Definition: GlobalValue.h:62
llvm::ModRefInfo::Ref
@ Ref
The access may reference the value stored in memory.
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::ModuleSummaryIndex::enableSplitLTOUnit
bool enableSplitLTOUnit() const
Definition: ModuleSummaryIndex.h:1241
fflagsToString
static std::string fflagsToString(FunctionSummary::FFlags F)
Definition: ModuleSummaryIndex.cpp:447
llvm::ARM_PROC::A
@ A
Definition: ARMBaseInfo.h:34
llvm::rdf::NodeId
uint32_t NodeId
Definition: RDFGraph.h:260
llvm::STATISTIC
STATISTIC(NumFunctions, "Total number of functions")
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::ModuleSummaryIndex::getFlags
uint64_t getFlags() const
Definition: ModuleSummaryIndex.cpp:93
StringMap.h
llvm::ModuleSummaryIndex::withGlobalValueDeadStripping
bool withGlobalValueDeadStripping() const
Definition: ModuleSummaryIndex.h:1209
llvm::GlobalValue::InternalLinkage
@ InternalLinkage
Rename collisions when linking (static functions).
Definition: GlobalValue.h:55
llvm::ValueInfo::getELFVisibility
GlobalValue::VisibilityTypes getELFVisibility() const
Returns the most constraining visibility among summaries.
Definition: ModuleSummaryIndex.cpp:43
llvm::ModuleSummaryIndex::setHasSyntheticEntryCounts
void setHasSyntheticEntryCounts()
Definition: ModuleSummaryIndex.h:1232
hasConstantFlag
static bool hasConstantFlag(const GlobalValueSummary *S)
Definition: ModuleSummaryIndex.cpp:516
llvm::ValueInfo
Struct that holds a reference to a particular GUID in a global value summary.
Definition: ModuleSummaryIndex.h:168
llvm::ValueInfo::canAutoHide
bool canAutoHide() const
Checks if all copies are eligible for auto-hiding (have flag set).
Definition: ModuleSummaryIndex.cpp:68
llvm::Twine::str
std::string str() const
Return the twine contents as a std::string.
Definition: Twine.cpp:17
llvm::DenseSet
Implements a dense probed hash-table based set.
Definition: DenseSet.h:268
llvm::ModuleSummaryIndex::isGUIDLive
bool isGUIDLive(GlobalValue::GUID GUID) const
Definition: ModuleSummaryIndex.cpp:175
llvm::cl::opt< bool >
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:192
x2
gcc mainline compiles it x2(%rip)
VI
@ VI
Definition: SIInstrInfo.cpp:7679
llvm::GlobalValueSummary::linkage
GlobalValue::LinkageTypes linkage() const
Return linkage type recorded for this global value.
Definition: ModuleSummaryIndex.h:402
uint64_t
llvm::ModuleSummaryIndex::dumpSCCs
void dumpSCCs(raw_ostream &OS)
Print out strongly connected components for debugging.
Definition: ModuleSummaryIndex.cpp:349
llvm::scc_iterator
Enumerate the SCCs of a directed graph in reverse topological order of the SCC DAG.
Definition: SCCIterator.h:42
llvm::ARM_AM::add
@ add
Definition: ARMAddressingModes.h:39
llvm::GlobalValue::WeakAnyLinkage
@ WeakAnyLinkage
Keep one copy of named function when linking (weak)
Definition: GlobalValue.h:52
llvm::ModuleSummaryIndex::getValueInfo
ValueInfo getValueInfo(const GlobalValueSummaryMapTy::value_type &R) const
Return a ValueInfo for the index value_type (convenient when iterating index).
Definition: ModuleSummaryIndex.h:1256
hasWriteOnlyFlag
static bool hasWriteOnlyFlag(const GlobalValueSummary *S)
Definition: ModuleSummaryIndex.cpp:510
llvm::DenseMap
Definition: DenseMap.h:714
I
#define I(x, y, z)
Definition: MD5.cpp:59
Attributes
AMDGPU Kernel Attributes
Definition: AMDGPULowerKernelAttributes.cpp:254
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:443
llvm::ModuleSummaryIndex::skipModuleByDistributedBackend
bool skipModuleByDistributedBackend() const
Definition: ModuleSummaryIndex.h:1234
llvm::FunctionSummary::makeDummyFunctionSummary
static FunctionSummary makeDummyFunctionSummary(std::vector< FunctionSummary::EdgeTy > Edges)
Create an empty FunctionSummary (with specified call edges).
Definition: ModuleSummaryIndex.h:614
llvm::make_pointee_range
iterator_range< pointee_iterator< WrappedIteratorT > > make_pointee_range(RangeT &&Range)
Definition: iterator.h:330
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::ModuleSummaryIndex::setWithDSOLocalPropagation
void setWithDSOLocalPropagation()
Definition: ModuleSummaryIndex.h:1222
llvm::X86AS::FS
@ FS
Definition: X86.h:188
llvm::FunctionSummary::FFlags
Flags specific to function summaries.
Definition: ModuleSummaryIndex.h:563
llvm::GlobalValue::AppendingLinkage
@ AppendingLinkage
Special purpose, only applies to global arrays.
Definition: GlobalValue.h:54
llvm::ModuleSummaryIndex::partiallySplitLTOUnits
bool partiallySplitLTOUnits() const
Definition: ModuleSummaryIndex.h:1244
llvm::ModuleSummaryIndex::exportToDot
void exportToDot(raw_ostream &OS, const DenseSet< GlobalValue::GUID > &GUIDPreservedSymbols) const
Export summary to dot file for GraphViz.
Definition: ModuleSummaryIndex.cpp:522
llvm::ModuleSummaryIndex::setFlags
void setFlags(uint64_t Flags)
Definition: ModuleSummaryIndex.cpp:112
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
ImportConstantsWithRefs
static cl::opt< bool > ImportConstantsWithRefs("import-constants-with-refs", cl::init(true), cl::Hidden, cl::desc("Import constant global variables with references"))
llvm::GlobalValue::WeakODRLinkage
@ WeakODRLinkage
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:53
llvm::detail::DenseSetImpl< ValueT, DenseMap< ValueT, detail::DenseSetEmpty, DenseMapInfo< ValueT >, detail::DenseSetPair< ValueT > >, DenseMapInfo< ValueT > >::contains
bool contains(const_arg_type_t< ValueT > V) const
Check if the set contains the given element.
Definition: DenseSet.h:185
uint32_t
llvm::ModuleSummaryIndex::collectDefinedGVSummariesPerModule
void collectDefinedGVSummariesPerModule(Map &ModuleToDefinedGVSummaries) const
Collect for each module the list of Summaries it defines (GUID -> Summary).
Definition: ModuleSummaryIndex.h:1504
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::GlobalValue::AvailableExternallyLinkage
@ AvailableExternallyLinkage
Available for inspection, not emission.
Definition: GlobalValue.h:49
llvm::GlobalValue::CommonLinkage
@ CommonLinkage
Tentative definitions.
Definition: GlobalValue.h:58
defineExternalNode
static void defineExternalNode(raw_ostream &OS, const char *Pfx, const ValueInfo &VI, GlobalValue::GUID Id)
Definition: ModuleSummaryIndex.cpp:491
llvm::ModuleSummaryIndex::canImportGlobalVar
bool canImportGlobalVar(GlobalValueSummary *S, bool AnalyzeRefs) const
Checks if we can import global variable from another module.
Definition: ModuleSummaryIndex.cpp:314
llvm::FunctionSummary::ExternalNode
static FunctionSummary ExternalNode
A dummy node to reference external functions that aren't in the index.
Definition: ModuleSummaryIndex.h:632
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::FunctionSummary
Function summary information to aid decisions and implementation of importing.
Definition: ModuleSummaryIndex.h:513
llvm::ModuleSummaryIndex::setWithGlobalValueDeadStripping
void setWithGlobalValueDeadStripping()
Definition: ModuleSummaryIndex.h:1212
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::GlobalValue::isInterposableLinkage
static bool isInterposableLinkage(LinkageTypes Linkage)
Whether the definition of this global may be replaced by something non-equivalent at link time.
Definition: GlobalValue.h:345
llvm::FunctionSummary::ParamAccess::RangeWidth
static constexpr uint32_t RangeWidth
Definition: ModuleSummaryIndex.h:579
linkageToString
static std::string linkageToString(GlobalValue::LinkageTypes LT)
Definition: ModuleSummaryIndex.cpp:418
llvm::ModuleSummaryIndex::getGlobalValueSummary
GlobalValueSummary * getGlobalValueSummary(const GlobalValue &GV, bool PerModuleIndex=true) const
Returns the first GlobalValueSummary for GV, asserting that there is only one if PerModuleIndex.
Definition: ModuleSummaryIndex.h:1366
llvm::GlobalValue::ProtectedVisibility
@ ProtectedVisibility
The GV is protected.
Definition: GlobalValue.h:65
llvm::FunctionSummary::specialRefCounts
std::pair< unsigned, unsigned > specialRefCounts() const
Definition: ModuleSummaryIndex.cpp:78
llvm::ModuleSummaryIndex::BitcodeSummaryVersion
static constexpr uint64_t BitcodeSummaryVersion
Definition: ModuleSummaryIndex.h:1124
llvm::GlobalValue::ExternalLinkage
@ ExternalLinkage
Externally visible function.
Definition: GlobalValue.h:48
llvm::ModuleSummaryIndex::isWriteOnly
bool isWriteOnly(const GlobalVarSummary *GVS) const
Definition: ModuleSummaryIndex.h:1227
llvm::ModuleSummaryIndex::setSkipModuleByDistributedBackend
void setSkipModuleByDistributedBackend()
Definition: ModuleSummaryIndex.h:1237
llvm::GlobalValue::PrivateLinkage
@ PrivateLinkage
Like Internal, but omit from symbol table.
Definition: GlobalValue.h:56
llvm::sys::path::filename
StringRef filename(StringRef path, Style style=Style::native)
Get filename.
Definition: Path.cpp:575
llvm::to_string
std::string to_string(const T &Value)
Definition: ScopedPrinter.h:63
getNodeLabel
static std::string getNodeLabel(const ValueInfo &VI, GlobalValueSummary *GVS)
Definition: ModuleSummaryIndex.cpp:474
getNodeVisualName
static std::string getNodeVisualName(GlobalValue::GUID Id)
Definition: ModuleSummaryIndex.cpp:466
llvm::ModuleSummaryIndex::collectDefinedFunctionsForModule
void collectDefinedFunctionsForModule(StringRef ModulePath, GVSummaryMapTy &GVSummaryMap) const
Collect for the given module the list of functions it defines (GUID -> Summary).
Definition: ModuleSummaryIndex.cpp:147
llvm::ModuleSummaryIndex::withAttributePropagation
bool withAttributePropagation() const
Definition: ModuleSummaryIndex.h:1216
propagateAttributesToRefs
static void propagateAttributesToRefs(GlobalValueSummary *S, DenseSet< ValueInfo > &MarkedNonReadWriteOnly)
Definition: ModuleSummaryIndex.cpp:189
llvm::cl::desc
Definition: CommandLine.h:414
llvm::GlobalValue::ExternalWeakLinkage
@ ExternalWeakLinkage
ExternalWeak linkage description.
Definition: GlobalValue.h:57
raw_ostream.h
llvm::AMDGPU::VGPRIndexMode::Id
Id
Definition: SIDefines.h:228
llvm::GlobalValue::LinkOnceODRLinkage
@ LinkOnceODRLinkage
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:51
llvm::Value
LLVM Value Representation.
Definition: Value.h:75