[ThinLTO] Implement summary visualizer

[evgeny777]

Summary

I find it useful on some occasions (especially when PGO is also used) to have ThinLTO combined summary exported to DOT file,
so it can be examined with GraphViz or (for large projects) analyzed with python scripts. For instance below is the graph, demonstrating
indirect call promotion of functions called cold and hot:

It shows cold and hot edges, refs (dashed lines), dead nodes (red) and is clustered by TU. This graph was obtained from following source file
(compiled with -O2 -fprofile-generate -flto=thin):

#include <stdio.h>
#include <math.h>
#include <stdlib.h>

double H = 0, C = 0;
void hot() __attribute__((noinline)) { H += (sin(H)*cos(H) + 1); }
void cold() __attribute__((noinline)) { C += 2*cos(C); }
void call_some(void (*fun)(), unsigned count) { fun(); }

int main(int argc, char *argv[]) {
  // Both cold and hot are called indirectly
  void (*func[])() = { hot, cold };

  for (int i = 0; i < atoi(argv[1]); ++i) {
    int d = rand() % 10;
    func[d > 7]();
  }
  printf("H = %f, C = %f\n", H, C);
  return (int)(C + H);
}

The dot file is dumped when caller provides --save-temps flag and contains node GUIDs. There is a small python script (approx 10 lines) used for annotation.
The code itself is a bit messed up and lacks test case, but for now I'm just wondering if it is of any interest to anybody

[tejohnson]

Nice! This looks very useful. What exactly does the python script do? I suppose the script must have been used to create the attached .png graph, since it has GV names and not GUIDs?

[mehdi_amini]

Neat!

[evgeny777]

Thanks for looking at it!
Currently I'm annotating graph in the following way

1. I use this shell command to generate file containing GUIDs and their identifiers from bitcode files:

find ./ -iname '*.o' | xargs llvm-modextract -n=0 -o - | llvm-lto -thin-lto -print-summary-global-ids - >& hashnames.txt

2. Use this python script (annotate.py) to annotate dot file (cat hashnames.txt | python annotate.py my.index.dot > annotated.dot)

import sys
import re

pat = re.compile(r'GUID [0-9]+\(([0-9]+)\) is (.*)')
pairs = []

for line in sys.stdin:
    m = pat.match(line)
    if m:
        pairs += [(m.group(1), m.group(2))]

with open(sys.argv[1]) as f:
    for line in f:
        l2 = line
        for p in pairs:
            l2 = line.replace("@" + str(p[0]), p[1])
            if l2 != line: break
        sys.stdout.write(l2)

3. Make graph png image using graphviz:

dot -Tpng -oannotate.png annotate.dot

[mehdi_amini]

I suspect it should be possible to do this after the ThinLink and add notation about the importing decision, promotion, dead-elimination, ... on every edge/nodes.

[evgeny777]

@mehdi_amini I've updated diff with one which no longer requires post-processing at the cost of having extra StringRef in GlobalValueSummaryInfo

add notation about the importing decision, promotion, dead-elimination, ... on every edge/nodes.

It this supposed to be done as comments in DOT file?

[mehdi_amini]

In D41297#958339, @evgeny777 wrote:

@mehdi_amini I've updated diff with one which no longer requires post-processing at the cost of having extra StringRef in GlobalValueSummaryInfo

add notation about the importing decision, promotion, dead-elimination, ... on every edge/nodes.

It this supposed to be done as comments in DOT file?

I don't know about the best way to display this, could be color, bold, label, or other markers.

[evgeny777]

I don't know about the best way to display this, could be color, bold, label, or other markers.

Currently the following scheme is used:

1. Nodes:

• Red - means node is dead (isLive() returns false)
• Yellow - not eligible to import
• Rectangles - functions
• Dotted rectangles - aliases
• Rounded rectangles - data members

2. Edges

• Solid - means function call. Color is different for different hotness value (black = unknown, blue = cold, brown = hot, bold red = critical)
• Dashed - means reference

Any suggestions?

[evgeny777]

Also it shows linkage for functions and variables. For each function flag bits and number of instructions are shown as well.

[evgeny777]

Any comments or suggestions?

[evgeny777]

Ping

[tejohnson]

Sorry for the delay! I have one big concern below. Will look at the code that does the graph emission next, I've only skimmed that part.

include/llvm/IR/ModuleSummaryIndex.h

95

I have a concern about keeping this string here. Who owns the string? I guess it is the string table created during bitcode reading. Do those even stay live through reading all input bitcode files and building the combined index? If not, saving a reference here is a problem. If so, then we currently have overhead that isn't typically necessary (we don't operate on IR or the names during the thin link).

I guess you added this to avoid needing the script to annotate these names instead of using the guids. Assuming we need to do something to keep these names live, I wonder if we can keep these names around somewhere under a debugging option instead (and emit the GUID by default).

145

Note that we'll never have a GV in the combined index case. Although it may be good to support emitting this for the per-module summary as well.

[evgeny777]

include/llvm/IR/ModuleSummaryIndex.h

95

Who owns the string?

My understanding is that linker owns this string because it loads bitcode file to memory and keeps it there during entire link phase. This StringRef points to strtab of the module, which is, to my understanding, is a region within MemoryBuffer owned by lld. Not so sure about gold.

I've found a problem though with VST_CODE_ENTRY/VST_CODE_FINENTRY. When they're being parsed their names are created on stack. This should be fixed.

I wonder if we can keep these names around somewhere under a debugging option instead (and emit the GUID by default).

Sounds reasonable, if there is no other way. I'll take a look on code reading/writing VST entries

145

Although it may be good to support emitting this for the per-module summary as well.

Yep, that's what I was thinking about.

[mehdi_amini]

include/llvm/IR/ModuleSummaryIndex.h

95

My understanding is that linker owns this string because it loads bitcode file to memory and keeps it there during entire link phase

At which point of the API is this guarantee? What about other tools than the linker that would manipulate a combined summary?

[evgeny777]

At which point of the API is this guarantee?

1. ThinLTO.ModuleMap stores BitcodeModule objects and uses them during entire thin link phase (until backend threads are launched)
2. BitcodeModule contains pointers to BC data, so this data should be actual for module to be parsed)
3. Module summary is exported to .dot in CombinedIndexHook which is invoked in the beginning of thin link phase

[tejohnson]

In D41297#974754, @evgeny777 wrote:

At which point of the API is this guarantee?

1. ThinLTO.ModuleMap stores BitcodeModule objects and uses them during entire thin link phase (until backend threads are launched)
2. BitcodeModule contains pointers to BC data, so this data should be actual for module to be parsed)
3. Module summary is exported to .dot in CombinedIndexHook which is invoked in the beginning of thin link phase

Note that the BitcodeModule itself holds a StringRef. It looks like this essentially points into the MemoryBuffer passed in as a MemoryBufferRef to InputFile::create, which is invoked by the linker. I don't recall what the guarantees are about how long that MemoryBufferRef has to stay valid. pcc may know since he added the InputFile and string table handling.

Mehdi also raises a good point that this wouldn't work if we used a tool that operated on an existing serialized combined index, which doesn't contain symbol names.

If we do have names available, as an aside, we could use them in many debugging messages that currently emit GUID during the thin link, which would be great. I just am concerned that the LTO API may need to explicitly keep these names around, in which case it would be good to do that only under a debugging option.

[evgeny777]

@tejohnson The BM.parseModule is invoked in the very end of thin link (see runThinLTOBackendThread). How can it work if it's not guaranteed that we have valid BC data till this moment? Note: parse module uses Stream

[tejohnson]

In D41297#974793, @evgeny777 wrote:

@tejohnson The BM.parseModule is invoked in the very end of thin link (see runThinLTOBackendThread). How can it work if it's not guaranteed that we have valid BC data till this moment? Note: parse module uses Stream

Good point. Since we create this map during combined index creation, and use it through the backends, then I guess we do have this available. Mehdi - any concerns I have missed?

We won't be able to dump the graph with names on an existing combined index, but that is much less important to support.

[tejohnson]

lib/IR/ModuleSummaryIndex.cpp

276

Why are the nodes and edges emitted this way - i.e. intra-module first, then cross-module? Why not just want the index and emit all the edges in one sweep? That would certainly be less expensive. You could just use the module Id stored in the module path string table (see ModuleSummaryIndex::getModuleId) instead of generating your own, or use the module hash

It might be nice to emit the full module path somewhere (maybe as a comment).

[evgeny777]

lib/IR/ModuleSummaryIndex.cpp

276

Why are the nodes and edges emitted this way

This is due to GraphViz specifics. When you define clusters (subgraphs), you should list intra-cluster edges inside cluster definitions, otherwise GraphViz won't display them correctly. So you have two options: (a) do not use clusters and list edges in any order or (b) use clusters and define intra-cluster nodes and edges within cluster definition and cross cluster edges outside of it.

You could just use the module Id stored in the module path string table
It might be nice to emit the full module path somewhere (maybe as a comment).

Makes sense

[mehdi_amini]

In D41297#974754, @evgeny777 wrote:

At which point of the API is this guarantee?

1. ThinLTO.ModuleMap stores BitcodeModule objects and uses them during entire thin link phase (until backend threads are launched)
2. BitcodeModule contains pointers to BC data, so this data should be actual for module to be parsed)
3. Module summary is exported to .dot in CombinedIndexHook which is invoked in the beginning of thin link phase

None of these seems like API guarantee to me, it sounds like "this is what actually happens in practice today in this particular workflow".

Can I write a tool that is using the ModuleSummaryIndexBitcodeReader (or the other entry point) to create the index and release the memory buffer that contains the bitcode?

include/llvm/IR/ModuleSummaryIndex.h

71

Are we size-sensitive here @tejohnson ?
Since the GV field is only used in per-module and and name only in combined summary, we could have some sort of union (variant if available).

[tejohnson]

In D41297#974946, @mehdi_amini wrote:

In D41297#974754, @evgeny777 wrote:

At which point of the API is this guarantee?

1. ThinLTO.ModuleMap stores BitcodeModule objects and uses them during entire thin link phase (until backend threads are launched)
2. BitcodeModule contains pointers to BC data, so this data should be actual for module to be parsed)
3. Module summary is exported to .dot in CombinedIndexHook which is invoked in the beginning of thin link phase

None of these seems like API guarantee to me, it sounds like "this is what actually happens in practice today in this particular workflow".

It seems it must be a guarantee of the LTO API, since ThinLTO.ModuleMap holds the BitcodeModule objects and accesses their buffers through and after the thin link.

Can I write a tool that is using the ModuleSummaryIndexBitcodeReader (or the other entry point) to create the index and release the memory buffer that contains the bitcode?

Presumably. The CombinedIndexHook that invokes this new dot dumper is only accessed via the LTO API here. But I suppose we could get in trouble if it was invoked on the index via another tool in the future. Not sure if there is a way to prevent other than documenting this StringRef clearly.

include/llvm/IR/ModuleSummaryIndex.h

71

Yeah that is a concern. I like the idea of unioning with the GV.

[mehdi_amini]

In D41297#974984, @tejohnson wrote:

In D41297#974946, @mehdi_amini wrote:

In D41297#974754, @evgeny777 wrote:

At which point of the API is this guarantee?

1. ThinLTO.ModuleMap stores BitcodeModule objects and uses them during entire thin link phase (until backend threads are launched)
2. BitcodeModule contains pointers to BC data, so this data should be actual for module to be parsed)
3. Module summary is exported to .dot in CombinedIndexHook which is invoked in the beginning of thin link phase

None of these seems like API guarantee to me, it sounds like "this is what actually happens in practice today in this particular workflow".

It seems it must be a guarantee of the LTO API, since ThinLTO.ModuleMap holds the BitcodeModule objects and accesses their buffers through and after the thin link.

Right, but the combined index lives in include/llvm/IR/ModuleSummaryIndex.h and the strings are populated when loading the index/bitcode in lib/Bitcode/Reader/BitcodeReader.cpp.
None of these have anything to do with LTO or the LTO API.

Can I write a tool that is using the ModuleSummaryIndexBitcodeReader (or the other entry point) to create the index and release the memory buffer that contains the bitcode?

Presumably. The CombinedIndexHook that invokes this new dot dumper is only accessed via the LTO API here. But I suppose we could get in trouble if it was invoked on the index via another tool in the future. Not sure if there is a way to prevent other than documenting this StringRef clearly.

Probably!

[evgeny777]

Changes:

• Var/function name StringRef is not saved for legacy summary formats (when VST is used instead of strtab).
• Now printing full module path in comment before cluster definition
• Added comments to every edge/node
• Added test case

[evgeny777]

ModuleId issue was also fixed

[tejohnson]

Thanks. Do you have an example of what this looks like now with a couple of modules and some cross-module edges?

include/llvm/IR/ModuleSummaryIndex.h

71

Please union the GV and Name fields as suggested, so that we don't bloat the size. You will likely need to know whether this is a combined index or not when accessing these. Currently we don't have a flag on the index, but one could be added. You can probably get by with checking whether there are any entries in the index's ModulePathStringTable though, since I believe that is empty for the per-module summary index.

94

Need to clearly document ownership of this string

lib/IR/ModuleSummaryIndex.cpp

174

This comment now belongs elsewhere.

190

Not sure what is meant by "without ValueInfo" - this function takes a ValueInfo and uses it.

213

Rename to something like TypeOrHotness instead?

281

Maybe use a different type of edge for the alias -> aliasee? I.e. another type beyond reference or call with hotness?

297

might as well add continue at the end of this if body since the subsequent handling is for the non-empty ModList case.

300

Since these are cross module edges, when would these be equal?

[evgeny777]

lib/IR/ModuleSummaryIndex.cpp

300

The edge representing call or ref is drawn to every module target symbol is defined. When target is a linkonce symbol there can be multiple edges representing a single call or ref, both intra-module and cross-module. As we've already drawn all intra-module edges before we skip it here.

[evgeny777]

lib/IR/ModuleSummaryIndex.cpp

297

Actually we add -1 to module list to draw an edge to an external node (like printf or atoi in the picture). This edge is being drawn in the loop below.

[evgeny777]

Addressed review comments

Here is what test case dot file looks like:

digraph Summary {
  // Module: /home/evgeny/work/llvm_out/build_ninja_Debug/test/ThinLTO/X86/Output/dot-dumper.ll.tmp1.bc
  subgraph cluster_0 {
    style = filled;
    color = lightgrey;
    label = "dot-dumper.ll.tmp1.bc";
    node [style=filled,fillcolor=lightblue];
    M0_9247563407992198212 [style="dotted,filled",shape="box",label="main_alias",fillcolor="red"]; // alias, dead
    M0_15822663052811949562 [shape="record",label="main|extern (inst: 4, ffl: 0000)}"]; // function
    // Edges:
    M0_9247563407992198212 -> M0_15822663052811949562 [style=dotted]; // alias
  }
  // Module: /home/evgeny/work/llvm_out/build_ninja_Debug/test/ThinLTO/X86/Output/dot-dumper.ll.tmp2.bc
  subgraph cluster_1 {
    style = filled;
    color = lightgrey;
    label = "dot-dumper.ll.tmp2.bc";
    node [style=filled,fillcolor=lightblue];
    M1_12110082535487358335 [shape="Mrecord",label="A|extern}"]; // variable
    M1_6699318081062747564 [shape="record",label="foo|extern (inst: 4, ffl: 0000)}",fillcolor="yellow"]; // function, not eligible to import
    M1_14608648041743670941 [shape="Mrecord",label="B|extern}"]; // variable
    M1_16434608426314478903 [shape="record",label="bar|extern (inst: 1, ffl: 0000)}",fillcolor="red"]; // function, dead
    // Edges:
    M1_6699318081062747564 -> M1_14608648041743670941 [style=dashed]; // ref
    M1_6699318081062747564 -> M1_12110082535487358335 [style=dashed]; // ref
  }
  M0_15822663052811949562 -> M1_12110082535487358335 [style=dashed]; // ref
  M0_15822663052811949562 -> M1_6699318081062747564 // call (hotness : Unknown)
}

Here is the picture

[tejohnson]

Thanks, just some minor stuff left.

include/llvm/IR/ModuleSummaryIndex.h

77

Better to initialize the appropriate union member when this is constructed, based on the value of IsAnalysis. I think that would just be in getOrInsertValuePtr, which could be passed IsAnalysis from its callers. Then init GV to nullptr or Name to "" depending on that flag.

154–165

Add an assert then that L.isFromAnalysis() == R.isFromAnalysis() ?

lib/Analysis/ModuleSummaryAnalysis.cpp

375

Please update all of these invocations to document the the constant bool param. E.g. "(/*IsPerformingAnalysis=*/true)"

lib/IR/ModuleSummaryIndex.cpp

214

I actually meant change the name of parameter Hotness to TypeOrHotness. The array can stay EdgeAttrs. Sorry for not being clear.

lib/Transforms/IPO/FunctionImport.cpp

520

We should never be computing dead symbols on a partial (per-module) index, so Index.isPerformingAnalysis should always be false. Suggest passing false here directly (with param name in comment).

lib/Transforms/IPO/LowerTypeTests.cpp

1532

Why is this one true? It doesn't seem like we should be marking as InAnalysis.

[evgeny777]

lib/Transforms/IPO/LowerTypeTests.cpp

1532

Yep, looks like a bug

[evgeny777]

Addressed review comments

[tejohnson]

LGTM
Thanks!

include/llvm/IR/ModuleSummaryIndex.h

void updateHotness(const HotnessType OtherHotness) {
     Hotness = std::max(Hotness, OtherHotness);
   }
 };
 
 class GlobalValueSummary;
 
 using GlobalValueSummaryList = std::vector<std::unique_ptr<GlobalValueSummary>>;
 
 struct GlobalValueSummaryInfo {
+  union NameOrGV {
+    NameOrGV(bool IsAnalysis) {
+      if (IsAnalysis)
+        GV = nullptr;
+      else
+        Name = "";
+    }
+
     /// The GlobalValue corresponding to this summary. This is only used in
-  /// per-module summaries.
-  const GlobalValue *GV = nullptr;
+    /// per-module summaries, when module analysis is being run.
+    const GlobalValue *GV;
+
+    /// Summary string representation. This StringRef points to BC module
+    /// string table and is valid until module data is stored in memory.
+    /// This is guaranteed to happen until runThinLTOBackend function is
+    /// called, so it is safe to use this field during thin link. This field
+    /// is only valid if summary index was loaded from BC file.
+    StringRef Name;
+  } U;
+
+  GlobalValueSummaryInfo(bool IsAnalysis) : U(IsAnalysis) {}
 
   /// List of global value summary structures for a particular value held
   /// in the GlobalValueMap. Requires a vector in the case of multiple
   /// COMDAT values of the same name.
   GlobalValueSummaryList SummaryList;
 };
 
 /// Map from global value GUID to corresponding summary structures. Use a
 /// std::map rather than a DenseMap so that pointers to the map's value_type
 /// (which are used by ValueInfo) are not invalidated by insertion. Also it will
 /// likely incur less overhead, as the value type is not very small and the size
 /// of the map is unknown, resulting in inefficiencies due to repeated
 /// insertions and resizing.
 using GlobalValueSummaryMapTy =
     std::map<GlobalValue::GUID, GlobalValueSummaryInfo>;
 
 /// Struct that holds a reference to a particular GUID in a global value
 /// summary.
 struct ValueInfo {
-  const GlobalValueSummaryMapTy::value_type *Ref = nullptr;
+  PointerIntPair<const GlobalValueSummaryMapTy::value_type *, 1, bool>
+      RefAndFlag;
 
   ValueInfo() = default;
-  ValueInfo(const GlobalValueSummaryMapTy::value_type *Ref) : Ref(Ref) {}
+  ValueInfo(bool IsAnalysis, const GlobalValueSummaryMapTy::value_type *R) {
+    RefAndFlag.setPointer(R);
+    RefAndFlag.setInt(IsAnalysis);
+  }
 
-  operator bool() const { return Ref; }
+  operator bool() const { return getRef(); }
 
-  GlobalValue::GUID getGUID() const { return Ref->first; }
-  const GlobalValue *getValue() const { return Ref->second.GV; }
+  GlobalValue::GUID getGUID() const { return getRef()->first; }
+  const GlobalValue *getValue() const {
+    assert(isFromAnalysis());
+    return getRef()->second.U.GV;
+  }
 
   ArrayRef<std::unique_ptr<GlobalValueSummary>> getSummaryList() const {
-    return Ref->second.SummaryList;
+    return getRef()->second.SummaryList;
+  }
+
+  StringRef name() const {
+    return isFromAnalysis() ? getRef()->second.U.GV->getName()
+                            : getRef()->second.U.Name;
+  }
+
+  bool isFromAnalysis() const { return RefAndFlag.getInt(); }
+
+  const GlobalValueSummaryMapTy::value_type *getRef() const {
+    return RefAndFlag.getPointer();
   }
 };
 
 template <> struct DenseMapInfo<ValueInfo> {
   static inline ValueInfo getEmptyKey() {
-    return ValueInfo((GlobalValueSummaryMapTy::value_type *)-1);
+    return ValueInfo(false, (GlobalValueSummaryMapTy::value_type *)-8);
   }
 
   static inline ValueInfo getTombstoneKey() {
-    return ValueInfo((GlobalValueSummaryMapTy::value_type *)-2);
+    return ValueInfo(false, (GlobalValueSummaryMapTy::value_type *)-16);
+  }
+
+  static inline bool isSpecialKey(ValueInfo V) {
+    return V == getTombstoneKey() || V == getEmptyKey();
   }
 
-  static bool isEqual(ValueInfo L, ValueInfo R) { return L.Ref == R.Ref; }
-  static unsigned getHashValue(ValueInfo I) { return (uintptr_t)I.Ref; }
+  static bool isEqual(ValueInfo L, ValueInfo R) {
+    // We are not supposed to mix ValueInfo(s) with different analysis flag
+    // in a same container.
+    assert(isSpecialKey(L) || isSpecialKey(R) ||
+           (L.isFromAnalysis() == R.isFromAnalysis()));
+    return L.getRef() == R.getRef();
+  }
+  static unsigned getHashValue(ValueInfo I) { return (uintptr_t)I.getRef(); }
 };
 
 /// \brief Function and variable summary information to aid decisions and
 /// implementation of importing.
 class GlobalValueSummary {
 public:
   /// \brief Sububclass discriminator (for dyn_cast<> et al.)
   enum SummaryKind : unsigned { AliasKind, FunctionKind, GlobalVarKind };
private:
   /// GUIDs, it will be mapped to 0.
   std::map<GlobalValue::GUID, GlobalValue::GUID> OidGuidMap;
 
   /// Indicates that summary-based GlobalValue GC has run, and values with
   /// GVFlags::Live==false are really dead. Otherwise, all values must be
   /// considered live.
   bool WithGlobalValueDeadStripping = false;
 
+  /// If true then we're performing analysis of IR module, filling summary
+  /// accordingly. The value of 'false' means we're reading summary from
+  /// BC or YAML source. Affects the type of value stored in NameOrGV union
+  bool IsAnalysis;
+
   std::set<std::string> CfiFunctionDefs;
   std::set<std::string> CfiFunctionDecls;
 
   // YAML I/O support.
   friend yaml::MappingTraits<ModuleSummaryIndex>;
 
   GlobalValueSummaryMapTy::value_type *
   getOrInsertValuePtr(GlobalValue::GUID GUID) {
-    return &*GlobalValueMap.emplace(GUID, GlobalValueSummaryInfo{}).first;
+    return &*GlobalValueMap.emplace(GUID, GlobalValueSummaryInfo(IsAnalysis)).first;
   }
 
 public:
+  // See IsAnalysis variable comment.
+  ModuleSummaryIndex(bool IsPerformingAnalysis)
+      : IsAnalysis(IsPerformingAnalysis) {}
+
+  bool isPerformingAnalysis() const { return IsAnalysis; }
+
   gvsummary_iterator begin() { return GlobalValueMap.begin(); }
   const_gvsummary_iterator begin() const { return GlobalValueMap.begin(); }
   gvsummary_iterator end() { return GlobalValueMap.end(); }
   const_gvsummary_iterator end() const { return GlobalValueMap.end(); }
   size_t size() const { return GlobalValueMap.size(); }
 
   bool withGlobalValueDeadStripping() const {
     return WithGlobalValueDeadStripping;
   }
   void setWithGlobalValueDeadStripping() {
     WithGlobalValueDeadStripping = true;
   }
 
   bool isGlobalValueLive(const GlobalValueSummary *GVS) const {
     return !WithGlobalValueDeadStripping || GVS->isLive();
   }
   bool isGUIDLive(GlobalValue::GUID GUID) const;
 
   /// Return a ValueInfo for GUID if it exists, otherwise return ValueInfo().
   ValueInfo getValueInfo(GlobalValue::GUID GUID) const {
     auto I = GlobalValueMap.find(GUID);
-    return ValueInfo(I == GlobalValueMap.end() ? nullptr : &*I);
+    return ValueInfo(IsAnalysis, I == GlobalValueMap.end() ? nullptr : &*I);
   }
 
   /// Return a ValueInfo for \p GUID.
   ValueInfo getOrInsertValueInfo(GlobalValue::GUID GUID) {
-    return ValueInfo(getOrInsertValuePtr(GUID));
+    return ValueInfo(IsAnalysis, getOrInsertValuePtr(GUID));
+  }
+
+  /// Return a ValueInfo for \p GUID setting value \p Name. 
+  ValueInfo getOrInsertValueInfo(GlobalValue::GUID GUID, StringRef Name) {
+    assert(!IsAnalysis);
+    auto VP = getOrInsertValuePtr(GUID);
+    VP->second.U.Name = Name;
+    return ValueInfo(IsAnalysis, VP);
   }
 
   /// Return a ValueInfo for \p GV and mark it as belonging to GV.
   ValueInfo getOrInsertValueInfo(const GlobalValue *GV) {
+    assert(IsAnalysis);
     auto VP = getOrInsertValuePtr(GV->getGUID());
-    VP->second.GV = GV;
-    return ValueInfo(VP);
+    VP->second.U.GV = GV;
+    return ValueInfo(IsAnalysis, VP);
   }
 
   /// Return the GUID for \p OriginalId in the OidGuidMap.
   GlobalValue::GUID getGUIDFromOriginalID(GlobalValue::GUID OriginalID) const {
     const auto I = OidGuidMap.find(OriginalID);
     return I == OidGuidMap.end() ? 0 : I->second;
   }
 
public:
   }
 
   /// Add a global value summary for the given ValueInfo.
   void addGlobalValueSummary(ValueInfo VI,
                              std::unique_ptr<GlobalValueSummary> Summary) {
     addOriginalName(VI.getGUID(), Summary->getOriginalName());
     // Here we have a notionally const VI, but the value it points to is owned
     // by the non-const *this.
-    const_cast<GlobalValueSummaryMapTy::value_type *>(VI.Ref)
+    const_cast<GlobalValueSummaryMapTy::value_type *>(VI.getRef())
         ->second.SummaryList.push_back(std::move(Summary));
   }
 
   /// Add an original name for the value of the given GUID.
   void addOriginalName(GlobalValue::GUID ValueGUID,
                        GlobalValue::GUID OrigGUID) {
     if (OrigGUID == 0 || ValueGUID == OrigGUID)
       return;
public:
   /// (GUID -> Summary).
   void collectDefinedFunctionsForModule(StringRef ModulePath,
                                         GVSummaryMapTy &GVSummaryMap) const;
 
   /// Collect for each module the list of Summaries it defines (GUID ->
   /// Summary).
   void collectDefinedGVSummariesPerModule(
       StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries) const;
+
+  /// Export summary to dot file for GraphViz.
+  void exportToDot(raw_ostream& OS) const;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_IR_MODULESUMMARYINDEX_H

include/llvm/IR/ModuleSummaryIndexYAML.h

template <> struct CustomMappingTraits<GlobalValueSummaryMapTy> {
   static void inputOne(IO &io, StringRef Key, GlobalValueSummaryMapTy &V) {
     std::vector<FunctionSummaryYaml> FSums;
     io.mapRequired(Key.str().c_str(), FSums);
     uint64_t KeyInt;
     if (Key.getAsInteger(0, KeyInt)) {
       io.setError("key not an integer");
       return;
     }
-    auto &Elem = V[KeyInt];
+    auto P = V.emplace(KeyInt, /*IsAnalysis=*/false);
+    auto &Elem = (*P.first).second;
     for (auto &FSum : FSums) {
       Elem.SummaryList.push_back(llvm::make_unique<FunctionSummary>(
           GlobalValueSummary::GVFlags(
               static_cast<GlobalValue::LinkageTypes>(FSum.Linkage),
               FSum.NotEligibleToImport, FSum.Live, FSum.IsLocal),
           0, FunctionSummary::FFlags{}, ArrayRef<ValueInfo>{},
           ArrayRef<FunctionSummary::EdgeTy>{}, std::move(FSum.TypeTests),
           std::move(FSum.TypeTestAssumeVCalls),

lib/Analysis/ModuleSummaryAnalysis.cpp

for (auto &Summary : VI.getSummaryList())
       Summary->setLive(true);
 }
 
 ModuleSummaryIndex llvm::buildModuleSummaryIndex(
     const Module &M,
     std::function<BlockFrequencyInfo *(const Function &F)> GetBFICallback,
     ProfileSummaryInfo *PSI) {
   assert(PSI);
-  ModuleSummaryIndex Index;
+  ModuleSummaryIndex Index(/*IsPerformingAnalysis=*/true);
 
   // Identify the local values in the llvm.used and llvm.compiler.used sets,
   // which should not be exported as they would then require renaming and
   // promotion, but we may have opaque uses e.g. in inline asm. We collect them
   // here because we use this information to mark functions containing inline
   // assembly calls as not importable.
   SmallPtrSet<GlobalValue *, 8> LocalsUsed;
   SmallPtrSet<GlobalValue *, 8> Used;

lib/Bitcode/Reader/BitcodeReader.cpp

std::string GlobalId =
       GlobalValue::getGlobalIdentifier(ValueName, Linkage, SourceFileName);
   auto ValueGUID = GlobalValue::getGUID(GlobalId);
   auto OriginalNameID = ValueGUID;
   if (GlobalValue::isLocalLinkage(Linkage))
     OriginalNameID = GlobalValue::getGUID(ValueName);
   if (PrintSummaryGUIDs)
     dbgs() << "GUID " << ValueGUID << "(" << OriginalNameID << ") is "
            << ValueName << "\n";
-  ValueIdToValueInfoMap[ValueID] =
-      std::make_pair(TheIndex.getOrInsertValueInfo(ValueGUID), OriginalNameID);
+  
+  // UseStrtab is false for legacy summary formats and value names are
+  // created on stack. We can't use them outside of parseValueSymbolTable.
+  ValueIdToValueInfoMap[ValueID] = std::make_pair(
+      TheIndex.getOrInsertValueInfo(ValueGUID, UseStrtab ? ValueName : ""),
+      OriginalNameID);
 }
 
 // Specialized value symbol table parser used when reading module index
 // blocks where we don't actually create global values. The parsed information
 // is saved in the bitcode reader for use when later parsing summaries.
 Error ModuleSummaryIndexBitcodeReader::parseValueSymbolTable(
     uint64_t Offset,
     DenseMap<unsigned, GlobalValue::LinkageTypes> &ValueIdToLinkageMap) {
Error BitcodeModule::readSummary(ModuleSummaryIndex &CombinedIndex,
   return R.parseModule();
 }
 
 // Parse the specified bitcode buffer, returning the function info index.
 Expected<std::unique_ptr<ModuleSummaryIndex>> BitcodeModule::getSummary() {
   BitstreamCursor Stream(Buffer);
   Stream.JumpToBit(ModuleBit);
 
-  auto Index = llvm::make_unique<ModuleSummaryIndex>();
+  auto Index =
+      llvm::make_unique<ModuleSummaryIndex>(/*IsPerformingAnalysis=*/false);
   ModuleSummaryIndexBitcodeReader R(std::move(Stream), Strtab, *Index,
                                     ModuleIdentifier, 0);
 
   if (Error Err = R.parseModule())
     return std::move(Err);
 
   return std::move(Index);
 }

lib/IR/ModuleSummaryIndex.cpp

 //===-- ModuleSummaryIndex.cpp - Module Summary Index ---------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the module index and summary classes for the
 // IR library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/ModuleSummaryIndex.h"
 #include "llvm/ADT/StringMap.h"
+#include "llvm/Support/Path.h"
 using namespace llvm;
 
 // Collect for the given module the list of function it defines
 // (GUID -> Summary).
 void ModuleSummaryIndex::collectDefinedFunctionsForModule(
     StringRef ModulePath, GVSummaryMapTy &GVSummaryMap) const {
   for (auto &GlobalList : *this) {
     auto GUID = GlobalList.first;
bool ModuleSummaryIndex::isGUIDLive(GlobalValue::GUID GUID) const {
   const auto &SummaryList = VI.getSummaryList();
   if (SummaryList.empty())
     return true;
   for (auto &I : SummaryList)
     if (isGlobalValueLive(I.get()))
       return true;
   return false;
 }
+
+namespace {
+struct Attributes {
+  void add(const Twine &Name, const Twine &Value,
+           const Twine &Comment = Twine());
+  std::string getAsString() const;
+
+  std::vector<std::string> Attrs;
+  std::string Comments;
+};
+
+struct Edge {
+  uint64_t SrcMod;
+  int Hotness;
+  GlobalValue::GUID Src;
+  GlobalValue::GUID Dst;
+};
+}
+
+void Attributes::add(const Twine &Name, const Twine &Value,
+                     const Twine &Comment) {
+  std::string A = Name.str();
+  A += "=\"";
+  A += Value.str();
+  A += "\"";
+  Attrs.push_back(A);
+  if (!Comment.isTriviallyEmpty()) {
+    if (Comments.empty())
+      Comments = " // ";
+    else
+      Comments += ", ";
+    Comments += Comment.str();
+  }
+}
+
+std::string Attributes::getAsString() const {
+  if (Attrs.empty())
+    return "";
+
+  std::string Ret = "[";
+  for (auto &A : Attrs)
+    Ret += A + ",";
+  Ret.pop_back();
+  Ret += "];";
+  Ret += Comments;
+  return Ret;
+}
+
+static std::string linkageToString(GlobalValue::LinkageTypes LT) {
+  switch (LT) {
+  case GlobalValue::ExternalLinkage:
+    return "extern";
+  case GlobalValue::AvailableExternallyLinkage:
+    return "av_ext";
+  case GlobalValue::LinkOnceAnyLinkage:
+    return "linkonce";
+  case GlobalValue::LinkOnceODRLinkage:
+    return "linkonce_odr";
+  case GlobalValue::WeakAnyLinkage:
+    return "weak";
+  case GlobalValue::WeakODRLinkage:
+    return "weak_odr";
+  case GlobalValue::AppendingLinkage:
+    return "appending";
+  case GlobalValue::InternalLinkage:
+    return "internal";
+  case GlobalValue::PrivateLinkage:
+    return "private";
+  case GlobalValue::ExternalWeakLinkage:
+    return "extern_weak";
+  case GlobalValue::CommonLinkage:
+    return "common";
+  }
+
+  return "<unknown>";
+}
+
+static std::string fflagsToString(FunctionSummary::FFlags F) {
+  auto FlagValue = [](unsigned V) { return V ? '1' : '0'; };
+  char FlagRep[] = {FlagValue(F.ReadNone), FlagValue(F.ReadOnly),
+                    FlagValue(F.NoRecurse), FlagValue(F.ReturnDoesNotAlias), 0};
+
+  return FlagRep;
+}
+
+// Get string representation of function instruction count and flags.
+static std::string getSummaryAttributes(GlobalValueSummary* GVS) {
+  auto *FS = dyn_cast_or_null<FunctionSummary>(GVS);
+  if (!FS)
+    return "";
+
+  return std::string("inst: ") + std::to_string(FS->instCount()) +
+         ", ffl: " + fflagsToString(FS->fflags());
+}
+
+static std::string getNodeVisualName(const ValueInfo &VI) {
+  return VI.name().empty() ? std::string("@") + std::to_string(VI.getGUID())
+                           : VI.name().str();
+}
+
+static std::string getNodeLabel(const ValueInfo &VI, GlobalValueSummary *GVS) {
+  if (isa<AliasSummary>(GVS))
+    return getNodeVisualName(VI);
+
+  std::string Attrs = getSummaryAttributes(GVS);
+  std::string Label =
+      getNodeVisualName(VI) + "|" + linkageToString(GVS->linkage());
+  if (!Attrs.empty())
+    Label += std::string(" (") + Attrs + ")";
+  Label += "}";
+
+  return Label;
+}
+
+// Write definition of external node, which doesn't have any
+// specific module associated with it. Typically this is function
+// or variable defined in native object or library.
+static void defineExternalNode(raw_ostream &OS, const char *Pfx,
+                               const ValueInfo &VI) {
+  auto StrId = std::to_string(VI.getGUID());
+  OS << "  " << StrId << " [label=\"" << getNodeVisualName(VI)
+     << "\"]; // defined externally\n";
+}
+
+void ModuleSummaryIndex::exportToDot(raw_ostream& OS) const {
+  std::vector<Edge> CrossModuleEdges;
+  DenseMap<GlobalValue::GUID, std::vector<uint64_t>> NodeMap;
+  StringMap<GVSummaryMapTy> ModuleToDefinedGVS;
+  collectDefinedGVSummariesPerModule(ModuleToDefinedGVS);
+
+  // Get node identifier in form MXXX_<GUID>. The MXXX prefix is required,
+  // because we may have multiple linkonce functions summaries.
+  auto NodeId = [](uint64_t ModId, GlobalValue::GUID Id) {
+    return ModId == (uint64_t)-1 ? std::to_string(Id)
+                                 : std::string("M") + std::to_string(ModId) +
+                                       "_" + std::to_string(Id);
+  };
+
+  auto DrawEdge = [&](const char *Pfx, int SrcMod, GlobalValue::GUID SrcId,
+                      int DstMod, GlobalValue::GUID DstId, int TypeOrHotness) {
+    // 0 corresponds to alias edge, 1 to ref edge, 2 to call with unknown
+    // hotness, ...
+    TypeOrHotness += 2;
+    static const char *EdgeAttrs[] = {
+        " [style=dotted]; // alias",
+        " [style=dashed]; // ref",
+        " // call (hotness : Unknown)",
+        " [color=blue]; // call (hotness : Cold)",
+        " // call (hotness : None)",
+        " [color=brown]; // call (hotness : Hot)",
+        " [style=bold,color=red]; // call (hotness : Critical)"};
+
+    assert(static_cast<size_t>(TypeOrHotness) <
+           sizeof(EdgeAttrs) / sizeof(EdgeAttrs[0]));
+    OS << Pfx << NodeId(SrcMod, SrcId) << " -> " << NodeId(DstMod, DstId)
+       << EdgeAttrs[TypeOrHotness] << "\n";
+  };
+
+  OS << "digraph Summary {\n";
+  for (auto &ModIt : ModuleToDefinedGVS) {
+    auto ModId = getModuleId(ModIt.first());
+    OS << "  // Module: " << ModIt.first() << "\n";
+    OS << "  subgraph cluster_" << std::to_string(ModId) << " {\n";
+    OS << "    style = filled;\n";
+    OS << "    color = lightgrey;\n";
+    OS << "    label = \"" << sys::path::filename(ModIt.first()) << "\";\n";
+    OS << "    node [style=filled,fillcolor=lightblue];\n";
+
+    auto &GVSMap = ModIt.second;
+    auto Draw = [&](GlobalValue::GUID IdFrom, GlobalValue::GUID IdTo, int Hotness) {
+      if (!GVSMap.count(IdTo)) {
+        CrossModuleEdges.push_back({ModId, Hotness, IdFrom, IdTo});
+        return;
+      }
+      DrawEdge("    ", ModId, IdFrom, ModId, IdTo, Hotness);
+    };
+
+    for (auto &SummaryIt : GVSMap) {
+      NodeMap[SummaryIt.first].push_back(ModId);
+      auto Flags = SummaryIt.second->flags();
+      Attributes A;
+      if (isa<FunctionSummary>(SummaryIt.second)) {
+        A.add("shape", "record", "function");
+      } else if (isa<AliasSummary>(SummaryIt.second)) {
+        A.add("style", "dotted,filled", "alias");
+        A.add("shape", "box");
+      } else {
+        A.add("shape", "Mrecord", "variable");
+      }
+
+      auto VI = getValueInfo(SummaryIt.first);
+      A.add("label", getNodeLabel(VI, SummaryIt.second));
+      if (!Flags.Live)
+        A.add("fillcolor", "red", "dead");
+      else if (Flags.NotEligibleToImport)
+        A.add("fillcolor", "yellow", "not eligible to import");
+
+      OS << "    " << NodeId(ModId, SummaryIt.first) << " " << A.getAsString()
+         << "\n";
+    }
+    OS << "    // Edges:\n";
+
+    for (auto &SummaryIt : GVSMap) {
+      auto *GVS = SummaryIt.second;
+      for (auto &R : GVS->refs())
+        Draw(SummaryIt.first, R.getGUID(), -1);
+
+      if (auto *AS = dyn_cast_or_null<AliasSummary>(SummaryIt.second)) {
+        auto AliaseeOrigId = AS->getAliasee().getOriginalName();
+        auto AliaseeId = getGUIDFromOriginalID(AliaseeOrigId);
+
+        Draw(SummaryIt.first, AliaseeId ? AliaseeId : AliaseeOrigId, -2);
+        continue;
+      }
+
+      if (auto *FS = dyn_cast_or_null<FunctionSummary>(SummaryIt.second))
+        for (auto &CGEdge : FS->calls())
+          Draw(SummaryIt.first, CGEdge.first.getGUID(),
+               static_cast<int>(CGEdge.second.Hotness));
+    }
+    OS << "  }\n";
+  }
+
+  for (auto &E : CrossModuleEdges) {
+    auto &ModList = NodeMap[E.Dst];
+    if (ModList.empty()) {
+      defineExternalNode(OS, "  ", getValueInfo(E.Dst));
+      // Add fake module to the list to draw an edge to an external node
+      // in the loop below.
+      ModList.push_back(-1);
+    }
+    for (auto DstMod : ModList)
+      // The edge representing call or ref is drawn to every module where target
+      // symbol is defined. When target is a linkonce symbol there can be
+      // multiple edges representing a single call or ref, both intra-module and
+      // cross-module. As we've already drawn all intra-module edges before we
+      // skip it here.
+      if (DstMod != E.SrcMod)
+        DrawEdge("  ", E.SrcMod, E.Src, DstMod, E.Dst, E.Hotness);
+  }
+
+  OS << "}";
+}

lib/LTO/LTO.cpp

 }
 
 LTO::RegularLTOState::RegularLTOState(unsigned ParallelCodeGenParallelismLevel,
                                       Config &Conf)
     : ParallelCodeGenParallelismLevel(ParallelCodeGenParallelismLevel),
       Ctx(Conf), CombinedModule(llvm::make_unique<Module>("ld-temp.o", Ctx)),
       Mover(llvm::make_unique<IRMover>(*CombinedModule)) {}
 
-LTO::ThinLTOState::ThinLTOState(ThinBackend Backend) : Backend(Backend) {
+LTO::ThinLTOState::ThinLTOState(ThinBackend Backend)
+    : Backend(Backend), CombinedIndex(/*IsPeformingAnalysis*/ false) {
   if (!Backend)
     this->Backend =
         createInProcessThinBackend(llvm::heavyweight_hardware_concurrency());
 }
 
 LTO::LTO(Config Conf, ThinBackend Backend,
          unsigned ParallelCodeGenParallelismLevel)
     : Conf(std::move(Conf)),

lib/LTO/LTOBackend.cpp

CombinedIndexHook = [=](const ModuleSummaryIndex &Index) {
     std::string Path = OutputFileName + "index.bc";
     std::error_code EC;
     raw_fd_ostream OS(Path, EC, sys::fs::OpenFlags::F_None);
     // Because -save-temps is a debugging feature, we report the error
     // directly and exit.
     if (EC)
       reportOpenError(Path, EC.message());
     WriteIndexToFile(Index, OS);
+
+    Path = OutputFileName + "index.dot";
+    raw_fd_ostream OSDot(Path, EC, sys::fs::OpenFlags::F_None);
+    if (EC)
+      reportOpenError(Path, EC.message());
+    Index.exportToDot(OSDot);
     return true;
   };
 
   return Error::success();
 }
 
 namespace {
 

lib/LTO/ThinLTOCodeGenerator.cpp

 }
 
 /**
  * Produce the combined summary index from all the bitcode files:
  * "thin-link".
  */
 std::unique_ptr<ModuleSummaryIndex> ThinLTOCodeGenerator::linkCombinedIndex() {
   std::unique_ptr<ModuleSummaryIndex> CombinedIndex =
-      llvm::make_unique<ModuleSummaryIndex>();
+      llvm::make_unique<ModuleSummaryIndex>(/*IsPeformingAnalysis=*/false);
   uint64_t NextModuleId = 0;
   for (auto &ModuleBuffer : Modules) {
     if (Error Err = readModuleSummaryIndex(ModuleBuffer.getMemBuffer(),
                                            *CombinedIndex, NextModuleId++)) {
       // FIXME diagnose
       logAllUnhandledErrors(
           std::move(Err), errs(),
           "error: can't create module summary index for buffer: ");

lib/Transforms/IPO/FunctionImport.cpp

if (!VI.getSummaryList().empty())
     return VI;
   // For SamplePGO, the indirect call targets for local functions will
   // have its original name annotated in profile. We try to find the
   // corresponding PGOFuncName as the GUID.
   // FIXME: Consider updating the edges in the graph after building
   // it, rather than needing to perform this mapping on each walk.
   auto GUID = Index.getGUIDFromOriginalID(VI.getGUID());
   if (GUID == 0)
-    return nullptr;
+    return ValueInfo();
   return Index.getValueInfo(GUID);
 }
 
 /// Compute the list of functions to import for a given caller. Mark these
 /// imported functions and the symbols they reference in their source module as
 /// exported from their source module.
 static void computeImportForFunction(
     const FunctionSummary &Summary, const ModuleSummaryIndex &Index,
for (auto &S : VI.getSummaryList())
       S->setLive(true);
   }
 
   // Add values flagged in the index as live roots to the worklist.
   for (const auto &Entry : Index)
     for (auto &S : Entry.second.SummaryList)
       if (S->isLive()) {
         DEBUG(dbgs() << "Live root: " << Entry.first << "\n");
-        Worklist.push_back(ValueInfo(&Entry));
+        Worklist.push_back(ValueInfo(/*IsAnalysis=*/false, &Entry));
         ++LiveSymbols;
         break;
       }
 
   // Make value live and add it to the worklist if it was not live before.
   // FIXME: we should only make the prevailing copy live here
   auto visit = [&](ValueInfo VI) {
     // FIXME: If we knew which edges were created for indirect call profiles,

lib/Transforms/IPO/LowerTypeTests.cpp

LowerTypeTestsModule::LowerTypeTestsModule(
   assert(!(ExportSummary && ImportSummary));
   Triple TargetTriple(M.getTargetTriple());
   Arch = TargetTriple.getArch();
   OS = TargetTriple.getOS();
   ObjectFormat = TargetTriple.getObjectFormat();
 }
 
 bool LowerTypeTestsModule::runForTesting(Module &M) {
-  ModuleSummaryIndex Summary;
+  ModuleSummaryIndex Summary(/*IsPerformingAnalysis=*/false);
 
   // Handle the command-line summary arguments. This code is for testing
   // purposes only, so we handle errors directly.
   if (!ClReadSummary.empty()) {
     ExitOnError ExitOnErr("-lowertypetests-read-summary: " + ClReadSummary +
                           ": ");
     auto ReadSummaryFile =
         ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(ClReadSummary)));

lib/Transforms/IPO/WholeProgramDevirt.cpp

PreservedAnalyses WholeProgramDevirtPass::run(Module &M,
   if (!DevirtModule(M, AARGetter, OREGetter, nullptr, nullptr).run())
     return PreservedAnalyses::all();
   return PreservedAnalyses::none();
 }
 
 bool DevirtModule::runForTesting(
     Module &M, function_ref<AAResults &(Function &)> AARGetter,
     function_ref<OptimizationRemarkEmitter &(Function *)> OREGetter) {
-  ModuleSummaryIndex Summary;
+  ModuleSummaryIndex Summary(/*IsPerformingAnalysis=*/false);
 
   // Handle the command-line summary arguments. This code is for testing
   // purposes only, so we handle errors directly.
   if (!ClReadSummary.empty()) {
     ExitOnError ExitOnErr("-wholeprogramdevirt-read-summary: " + ClReadSummary +
                           ": ");
     auto ReadSummaryFile =
         ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(ClReadSummary)));

test/ThinLTO/X86/Inputs/dot-dumper.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@A = local_unnamed_addr global i32 10, align 4
+@B = local_unnamed_addr global i32 20, align 4
+
+; Function Attrs: norecurse nounwind readonly uwtable
+define i32 @foo() local_unnamed_addr #0 {
+  %1 = load i32, i32* @B, align 4
+  %2 = load i32, i32* @A, align 4
+  %3 = add nsw i32 %2, %1
+  ret i32 %3
+}
+
+; Function Attrs: norecurse nounwind readnone uwtable
+define i32 @bar() local_unnamed_addr {
+  ret i32 42
+}
+
+attributes #0 = { noinline }

test/ThinLTO/X86/dot-dumper.ll

+; RUN: opt -module-summary %s -o %t1.bc
+; RUN: opt -module-summary %p/Inputs/dot-dumper.ll -o %t2.bc
+; RUN: llvm-lto2 run -save-temps %t1.bc %t2.bc -o %t3 \
+; RUN:  -r=%t1.bc,main,px \
+; RUN:  -r=%t1.bc,main_alias,p \
+; RUN:  -r=%t1.bc,foo, \
+; RUN:  -r=%t1.bc,A, \
+; RUN:  -r=%t2.bc,foo,p \
+; RUN:  -r=%t2.bc,bar,p \
+; RUN:  -r=%t2.bc,A,p \
+; RUN:  -r=%t2.bc,B,p
+; RUN: cat %t3.index.dot | FileCheck %s
+
+; CHECK:        digraph Summary
+; CHECK-NEXT:      Module:
+
+; CHECK-LABEL:     subgraph cluster_0
+; Node definitions can appear in any order, but they should go before edge list.
+; CHECK-DAG:         M0_[[MAIN_ALIAS:[0-9]+]] [{{.*}}main_alias{{.*}}]; // alias, dead
+; CHECK-DAG:         M0_[[MAIN:[0-9]+]] [{{.*}}main|extern{{.*}}]; // function
+; CHECK:             // Edges:
+; CHECK-NEXT:        M0_[[MAIN_ALIAS]] -> M0_[[MAIN]] [{{.*}}]; // alias
+
+; CHECK-LABEL:     subgraph cluster_1 {
+; CHECK:             M1_[[A:[0-9]+]] [{{.*}}A|extern{{.*}}]; // variable
+
+; CHECK-DAG:         M1_[[FOO:[0-9]+]] [{{.*}}foo|extern{{.*}}]; // function, not eligible to import
+; CHECK-DAG:         M1_[[B:[0-9]+]] [{{.*}}B|extern{{.*}}]; // variable
+; CHECK-DAG:         M1_[[BAR:[0-9]+]] [{{.*}}bar|extern{{.*}}]; // function, dead
+; CHECK:             Edges:
+
+; Order of edges in dot file is undefined
+; CHECK-DAG:         M1_[[FOO]] -> M1_[[B]] [{{.*}}]; // ref
+; CHECK-DAG:         M1_[[FOO]] -> M1_[[A]] [{{.*}}]; // ref
+; CHECK:           }
+
+; Cross-module edges
+; CHECK-DAG:       M0_[[MAIN]] -> M1_[[FOO]] // call
+; CHECK-DAG:       M0_[[MAIN]] -> M1_[[A]] [{{.*}}]; // ref
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@A = external local_unnamed_addr global i32, align 4
+
+; Function Attrs: nounwind uwtable
+define i32 @main() local_unnamed_addr {
+  %1 = tail call i32 (...) @foo()
+  %2 = load i32, i32* @A, align 4
+  %3 = add nsw i32 %2, %1
+  ret i32 %3
+}
+@main_alias = weak_odr alias i32 (), i32 ()* @main
+declare i32 @foo(...) local_unnamed_addr

tools/llvm-lto/llvm-lto.cpp

static void listSymbols(const TargetOptions &Options) {
   }
 }
 
 /// Create a combined index file from the input IR files and write it.
 ///
 /// This is meant to enable testing of ThinLTO combined index generation,
 /// currently available via the gold plugin via -thinlto.
 static void createCombinedModuleSummaryIndex() {
-  ModuleSummaryIndex CombinedIndex;
+  ModuleSummaryIndex CombinedIndex(/*IsPerformingAnalysis=*/false);
   uint64_t NextModuleId = 0;
   for (auto &Filename : InputFilenames) {
     ExitOnError ExitOnErr("llvm-lto: error loading file '" + Filename + "': ");
     std::unique_ptr<MemoryBuffer> MB =
         ExitOnErr(errorOrToExpected(MemoryBuffer::getFileOrSTDIN(Filename)));
     ExitOnErr(readModuleSummaryIndex(*MB, CombinedIndex, ++NextModuleId));
   }
   std::error_code EC;