[ThinLTO] YAML traits for module summaries

[ncharlie]

Summary

[ThinLTO] Dump YAML for module summaries

Adds YAML traits for module summaries so dumps can include summary information for functions, global values, and aliases.

[ncharlie]

Oops - got rid of old llvm-dis code.

[pcc]

Can you split this into two patches (both with their own tests), one which adds the subcommand and the other which adds the new YAML output?

tools/llvm-dis/llvm-dis.cpp

155

This seems like an unrelated change.

[ncharlie]

include/llvm/IR/ModuleSummaryIndexYAML.h

247

Some of these traits are duplicated. I could create a second struct called SharedSummaryYaml or something to deduplicate these fields, if anyone thinks they're worth centralizing.

278

I couldn't figure out how to thread a pointer to the Index down to the code that needs it (i.e. structs that are nested deeper in and have their own MappingTraits), so I left it here for now. If anyone has recommendations for a better place to put this, please let me know.

[ncharlie]

In D34063#777137, @pcc wrote:

Can you split this into two patches (both with their own tests), one which adds the subcommand and the other which adds the new YAML output?

Sorry - the bit you commented on wasn't supposed to be there - that was old code I forgot to remove. Do you want the new YAML code and llvm-lto2 subcommand to be in separate patches?

[pcc]

In D34063#777149, @ncharlie wrote:

Do you want the new YAML code and llvm-lto2 subcommand to be in separate patches?

Yes, please.

[mehdi_amini]

include/llvm/IR/ModuleSummaryIndex.h

536

Never seen "Oid" used here before.

Also s/dissassembly/disassembly and s/stringified//

537

Do we want this on all the time? Is this a fundamental property of the Index?
It isn't clear to me if it isn't just a debugging tool that map to the IR when available right now?

650

Return a const ref, and don't name it find... but get...OrEmpty if you want this API contract.

[ncharlie]

Addressed some updates from the comments.

[ncharlie]

include/llvm/IR/ModuleSummaryIndex.h

537

How would you recommend making this an optional debugging option? Would a constructor argument work?

[mehdi_amini]

include/llvm/IR/ModuleSummaryIndex.h

537

Is this information in the index in the bitcode?
If not then it can be reconstructed at dump time.

[ncharlie]

include/llvm/IR/ModuleSummaryIndex.h

537

The reason I'm storing the map in the index is because I only have access to the ValueName when the bitcode is being parsed in ModuleSummaryIndexBitcodeReader (see BitcodeReader.cpp:4715 in this patch). Also, when the YAML is being generated, I'm only given a pointer to a ModuleSummaryIndex, which is why the map is in that class.

[tejohnson]

include/llvm/IR/ModuleSummaryIndex.h

537

The value name is available on the GlobalValue (Value::getName()), as is the GUID (getGUID()). So you can just walk the Module's list of global_objects() (which gives you all the functions and global variables) and the list of aliases(), and compute the mapping.

That being said, I am not familiar enough with the YAML support to know how to get an additional object (either the Module, or a mapping pre-computed by the client or a wrapper function), passed down to where you need it. pcc may have some insight.

[mehdi_amini]

include/llvm/IR/ModuleSummaryIndex.h

537

Also, when the YAML is being generated, I'm only given a pointer to a ModuleSummaryIndex, which is why the map is in that class.

Then just modify the YAML to get an optional Module * as well? If you get it then you have names available, otherwise not.
Since it wouldn't roundtrip the YAML, I'd display it as a comment next to the GUID.

[ncharlie]

include/llvm/IR/ModuleSummaryIndex.h

537

The value name is available on the GlobalValue (Value::getName()), as is the GUID (getGUID()). So you can just walk the Module's list of global_objects()

Then just modify the YAML to get an optional Module * as well?

OK, I'll look into to this. I didn't realize there was already a map that stored the names in the Module class, so now I really want to get rid of my duplicate.

[tejohnson]

include/llvm/IR/ModuleSummaryIndex.h

537

It isn't really a map, but rather the global values are available from the Module, and as I mentioned in my comment (just above Mehdi's), the names and guids are available on the global values.

[ncharlie]

include/llvm/IR/ModuleSummaryIndex.h

537

Then just modify the YAML to get an optional Module * as well?

After looking into this, I can see two options for doing this.

1. Create a struct that holds both the Module * and the ModuleSummaryIndex, and output the new struct. I went part way down this path today, and I definitely think it's possible to do this, but it might result in some slightly odd code in some places - especially when reading in YAML (since it may not always be entirely obvious why a ModuleSummaryIndex and Module * have to be tracked together).
2. Add a Module * or getModule function to the ModuleSummaryIndex - I think this option is the cleanest and simplest implementation, despite adding a bit more information to the ModuleSummaryIndex class.

If there's some way to get a Module from a ModuleID or ModuleHash, that could work as well, but I'm not sure if it's possible.

Let me know which one you guys think is the best.

[mehdi_amini]

include/llvm/IR/ModuleSummaryIndex.h

537

I'm not sure we're all on the same track.

Names are never part of the summaries IIRC. So when you only work to/from YAML you don't have any names. Which is why I mentioned that the names in the YAML can only be comments.

I don't expect any change to include/llvm/IR/ModuleSummaryIndex.h ; it should be fully handled in the routine that dumps to YAML: it should take an optional Module. The first it can do is build a map from GUID -> Name for every symbol in the module. The YAML dump takes the summary index and this map and process from here.

[ncharlie]

include/llvm/IR/ModuleSummaryIndex.h

537

Got it - I'll pull my changes from the ModuleSummaryIndex and only worry about the names at dump time.

[ncharlie]

Fixes according to comments.

[tejohnson]

Can you add some test cases?

include/llvm/IR/ModuleSummaryIndexYAML.h

247

Yes I think that would be good. How about GlobalValueSummaryYaml, to mirror the class structure of the summaries themselves.

355

Also need to iterate over the refs() here and for alias and global var summaries (refs() is in the GlobalValueSummary base class)

410

Should there be an assert here that this is never invoked then?

424

Needs clang format. I believe you will also need to iterate over the aliases doing the same thing (global objects only includes functions and globalvars).

[ncharlie]

In D34063#784939, @tejohnson wrote:

Can you add some test cases?

Sure. How should I be testing the output?

[tejohnson]

In D34063#785295, @ncharlie wrote:

In D34063#784939, @tejohnson wrote:

Can you add some test cases?

Sure. How should I be testing the output?

With the llvm-lto2 support you are adding in D34080 - it's already approved so can go in.

[ncharlie]

Added test, further cleanup.

[ncharlie]

formatting

[ncharlie]

include/llvm/IR/ModuleSummaryIndexYAML.h

410

I realized that mapping wasn't necessary so I removed it.

[mehdi_amini]

include/llvm/IR/ModuleSummaryIndexYAML.h

424

There is a helper for this: Module::global_values()

(also: prefer for-range loops, and variable name needs to be uppercase).

[ncharlie]

Updated GlobalValue loop.

[sfertile]

include/llvm/IR/ModuleSummaryIndexYAML.h

374

GVSum is unused, which will introduce a warning.

[tejohnson]

Looks really close, just a few minor suggestions/nits left.

include/llvm/IR/ModuleSummaryIndexYAML.h

374

You can use "isa" instead of "dyn_cast" here now

412

Minor nit: prefer no braces around single statement for and if bodies.

include/llvm/Support/YAMLTraits.h

659 ↗

(On Diff #103952)

Ditto on no braces preferred.

test/tools/llvm-lto2/X86/dump-summary-yaml.ll

14 ↗

(On Diff #103952)

For the lines that have names, can you check for the names as well? You could either put in the expected GUID value, or use a regex to accept any GUID #. The FileCheck regex format for matching anything is: {{.*}}

[ncharlie]

test/tools/llvm-lto2/X86/dump-summary-yaml.ll

14 ↗

(On Diff #103952)

Added the regex to match the GUIDs now.

I didn't check for names, because the current llvm-lto2 pass won't print them out, because it needs to pass in a special struct with that includes a Module pointer for the name. Since the llvm-lto2 dump summary patch doesn't support the struct yet (as it's in this patch), I didn't enable the names in the other patch yet. I'll need to create another patch once both these patches are merged in so llvm-lto2 prints the names in the summary.

[tejohnson]

test/tools/llvm-lto2/X86/dump-summary-yaml.ll

14 ↗

(On Diff #103952)

I think the other patch is approved, and can go in now. Then since you are adding the name mapping functionality in this patch, I would say go ahead and add the llvm-lto2 name dumping in this patch.

[ncharlie]

Added names to dump-summary in llvm-lto2.

[tejohnson]

Can you commit D34080 and update the patch so it only shows the differences relative to that?

[ncharlie]

Applied D34080

removed test/tools/llvm-lto2/X86/dump-summary.ll from D34080 since it was more of a temporary placeholder test before test/tools/llvm-lto2/X86/dump-summary-yaml.ll could be added.

include/llvm/IR/ModuleSummaryIndex.h

private:
   /// Holds strings for combined index, mapping to the corresponding module ID.
   ModulePathStringTableTy ModulePathStringTable;
 
   /// Mapping from type identifiers to summary information for that type
   /// identifier.
   // FIXME: Add bitcode read/write support for this field.
   std::map<std::string, TypeIdSummary> TypeIdMap;
 
+  // Maps Oid GUID to the stringified value name (for dissassembly)
+  std::map<GlobalValue::GUID, std::string> OidToValueName;
+
   /// Mapping from original ID to GUID. If original ID can map to multiple
   /// 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;
public:
 
   /// Add a global value summary for a value of the given name.
   void addGlobalValueSummary(StringRef ValueName,
                              std::unique_ptr<GlobalValueSummary> Summary) {
     addGlobalValueSummary(getOrInsertValueInfo(GlobalValue::getGUID(ValueName)),
                           std::move(Summary));
   }
 
+  // Add an OID to ValueName to the map tracking them for disassembly
+  void addOidToValueName(GlobalValue::GUID OID, std::string ValueName) {
+    OidToValueName.insert(
+        std::pair<GlobalValue::GUID, std::string>(OID, ValueName));
+  }
+
   /// 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)
         ->second.SummaryList.push_back(std::move(Summary));
auto Summary =
                       [&](const std::unique_ptr<GlobalValueSummary> &Summary) {
                         return Summary->modulePath() == ModuleId;
                       });
     if (Summary == CalleeInfo.getSummaryList().end())
       return nullptr;
     return Summary->get();
   }
 
+  std::string findOidToValueName(const GlobalValue::GUID G) const {
+    auto s = OidToValueName.find(G);
+    if (s != OidToValueName.end()) {
+      return s->second;
+    }
+    return "";
+  }
+
   /// Returns the first GlobalValueSummary for \p GV, asserting that there
   /// is only one if \p PerModuleIndex.
   GlobalValueSummary *getGlobalValueSummary(const GlobalValue &GV,
                                             bool PerModuleIndex = true) const {
     assert(GV.hasName() && "Can't get GlobalValueSummary for GV with no name");
     return getGlobalValueSummary(GlobalValue::getGUID(GV.getName()),
                                  PerModuleIndex);
   }

include/llvm/IR/ModuleSummaryIndexYAML.h

static void enumeration(IO &io, TypeTestResolution::Kind &value) {
     io.enumCase(value, "Unsat", TypeTestResolution::Unsat);
     io.enumCase(value, "ByteArray", TypeTestResolution::ByteArray);
     io.enumCase(value, "Inline", TypeTestResolution::Inline);
     io.enumCase(value, "Single", TypeTestResolution::Single);
     io.enumCase(value, "AllOnes", TypeTestResolution::AllOnes);
   }
 };
 
+template <> struct ScalarEnumerationTraits<CalleeInfo::HotnessType> {
+  static void enumeration(IO &io, CalleeInfo::HotnessType &value) {
+    io.enumCase(value, "Unknown", CalleeInfo::HotnessType::Unknown);
+    io.enumCase(value, "Cold", CalleeInfo::HotnessType::Cold);
+    io.enumCase(value, "None", CalleeInfo::HotnessType::None);
+    io.enumCase(value, "Hot", CalleeInfo::HotnessType::Hot);
+  }
+};
+
+template <> struct ScalarEnumerationTraits<GlobalValueSummary::SummaryKind> {
+  static void enumeration(IO &io, GlobalValueSummary::SummaryKind &value) {
+    io.enumCase(value, "Alias", GlobalValueSummary::SummaryKind::AliasKind);
+    io.enumCase(value, "Function",
+                GlobalValueSummary::SummaryKind::FunctionKind);
+    io.enumCase(value, "GlobalVar",
+                GlobalValueSummary::SummaryKind::GlobalVarKind);
+  }
+};
+
 template <> struct MappingTraits<TypeTestResolution> {
   static void mapping(IO &io, TypeTestResolution &res) {
     io.mapOptional("Kind", res.TheKind);
     io.mapOptional("SizeM1BitWidth", res.SizeM1BitWidth);
   }
 };
 
 template <>

 
 template <> struct MappingTraits<TypeIdSummary> {
   static void mapping(IO &io, TypeIdSummary& summary) {
     io.mapOptional("TTRes", summary.TTRes);
     io.mapOptional("WPDRes", summary.WPDRes);
   }
 };
 
+struct CalleeInfoYaml {
+  std::string Name;
+  GlobalValue::GUID GUID;
+  CalleeInfo::HotnessType Hotness;
+};
+
 struct FunctionSummaryYaml {
-  unsigned Linkage;
+  GlobalValue::GUID GUID;
+  GlobalValueSummary::SummaryKind Kind;
+  GlobalValue::LinkageTypes Linkage;
   bool NotEligibleToImport, Live;
+  unsigned InstCount;
+  std::vector<CalleeInfoYaml> Calls;
+
   std::vector<uint64_t> TypeTests;
   std::vector<FunctionSummary::VFuncId> TypeTestAssumeVCalls,
       TypeCheckedLoadVCalls;
   std::vector<FunctionSummary::ConstVCall> TypeTestAssumeConstVCalls,
       TypeCheckedLoadConstVCalls;
 };
 
+struct GlobalVarSummaryYaml {
+  GlobalValue::GUID GUID;
+  GlobalValueSummary::SummaryKind Kind;
+  GlobalValue::LinkageTypes Linkage;
+  bool NotEligibleToImport, Live;
+};
+
+struct AliasSummaryYaml {
+  GlobalValue::GUID GUID;
+  GlobalValueSummary::SummaryKind Kind;
+  GlobalValue::LinkageTypes Linkage;
+  bool NotEligibleToImport, Live;
+  std::string Aliasee;
+};
+
 } // End yaml namespace
 } // End llvm namespace
 
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(uint64_t)
 
 namespace llvm {
 namespace yaml {
 

 } // End llvm namespace
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummary::VFuncId)
 LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummary::ConstVCall)
 
 namespace llvm {
 namespace yaml {
 
+template <> struct MappingTraits<CalleeInfoYaml> {
+  static void mapping(IO &io, CalleeInfoYaml &summary) {
+    io.mapOptional("Name", summary.Name);
+    io.mapOptional("GUID", summary.GUID);
+    io.mapOptional("Hotness", summary.Hotness);
+  }
+};
+
 template <> struct MappingTraits<FunctionSummaryYaml> {
   static void mapping(IO &io, FunctionSummaryYaml& summary) {
+    io.mapOptional("GUID", summary.GUID);
+    io.mapOptional("Kind", summary.Kind);
     io.mapOptional("Linkage", summary.Linkage);
     io.mapOptional("NotEligibleToImport", summary.NotEligibleToImport);
     io.mapOptional("Live", summary.Live);
+    io.mapOptional("InstCount", summary.InstCount);
+    io.mapOptional("Calls", summary.Calls);
     io.mapOptional("TypeTests", summary.TypeTests);
     io.mapOptional("TypeTestAssumeVCalls", summary.TypeTestAssumeVCalls);
     io.mapOptional("TypeCheckedLoadVCalls", summary.TypeCheckedLoadVCalls);
     io.mapOptional("TypeTestAssumeConstVCalls",
                    summary.TypeTestAssumeConstVCalls);
     io.mapOptional("TypeCheckedLoadConstVCalls",
                    summary.TypeCheckedLoadConstVCalls);
   }
 };
 
+template <> struct MappingTraits<GlobalVarSummaryYaml> {
+  static void mapping(IO &io, GlobalVarSummaryYaml &summary) {
+    io.mapOptional("GUID", summary.GUID);
+    io.mapOptional("Kind", summary.Kind);
+    io.mapOptional("Linkage", summary.Linkage);
+    io.mapOptional("NotEligibleToImport", summary.NotEligibleToImport);
+    io.mapOptional("Live", summary.Live);
+  }
+};
+
+template <> struct MappingTraits<AliasSummaryYaml> {
+  static void mapping(IO &io, AliasSummaryYaml &summary) {
+    io.mapOptional("GUID", summary.GUID);
+    io.mapOptional("Kind", summary.Kind);
+    io.mapOptional("Linkage", summary.Linkage);
+    io.mapOptional("NotEligibleToImport", summary.NotEligibleToImport);
+    io.mapOptional("Live", summary.Live);
+    io.mapOptional("Aliasee", summary.Aliasee);
+  }
+};
+
 } // End yaml namespace
 } // End llvm namespace
 
 LLVM_YAML_IS_STRING_MAP(TypeIdSummary)
 LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummaryYaml)
+LLVM_YAML_IS_SEQUENCE_VECTOR(CalleeInfoYaml)
+LLVM_YAML_IS_SEQUENCE_VECTOR(GlobalVarSummaryYaml)
+LLVM_YAML_IS_SEQUENCE_VECTOR(AliasSummaryYaml)
+LLVM_YAML_IS_SEQUENCE_VECTOR(std::string)
 
 namespace llvm {
 namespace yaml {
 
+struct NGVMValue {
+  ModuleSummaryIndex *Index;
+  GlobalValue::GUID GUID;
+  GlobalValueSummaryInfo *Summary;
+};
+using NamedGlobalValueMap = std::map<std::string, struct NGVMValue>;
+
+template <> struct ScalarEnumerationTraits<GlobalValue::LinkageTypes> {
+  static void enumeration(IO &io, GlobalValue::LinkageTypes &value) {
+    io.enumCase(value, "ExternalLinkage",
+                GlobalValue::LinkageTypes::ExternalLinkage);
+    io.enumCase(value, "AvailableExternallyLinkage",
+                GlobalValue::LinkageTypes::AvailableExternallyLinkage);
+    io.enumCase(value, "LinkOnceAnyLinkage",
+                GlobalValue::LinkageTypes::LinkOnceAnyLinkage);
+    io.enumCase(value, "LinkOnceODRLinkage",
+                GlobalValue::LinkageTypes::LinkOnceODRLinkage);
+    io.enumCase(value, "WeakAnyLinkage",
+                GlobalValue::LinkageTypes::WeakAnyLinkage);
+    io.enumCase(value, "WeakODRLinkage",
+                GlobalValue::LinkageTypes::WeakODRLinkage);
+    io.enumCase(value, "AppendingLinkage",
+                GlobalValue::LinkageTypes::AppendingLinkage);
+    io.enumCase(value, "InternalLinkage",
+                GlobalValue::LinkageTypes::InternalLinkage);
+    io.enumCase(value, "PrivateLinkage",
+                GlobalValue::LinkageTypes::PrivateLinkage);
+    io.enumCase(value, "ExternalWeakLinkage",
+                GlobalValue::LinkageTypes::ExternalWeakLinkage);
+    io.enumCase(value, "CommonLinkage",
+                GlobalValue::LinkageTypes::CommonLinkage);
+  }
+};
+
 // FIXME: Add YAML mappings for the rest of the module summary.
-template <> struct CustomMappingTraits<GlobalValueSummaryMapTy> {
-  static void inputOne(IO &io, StringRef Key, GlobalValueSummaryMapTy &V) {
+template <> struct CustomMappingTraits<NamedGlobalValueMap> {
+  static void inputOne(IO &io, StringRef Key, NamedGlobalValueMap &V) {
     std::vector<FunctionSummaryYaml> FSums;
+    std::vector<GlobalVarSummaryYaml> GVSums;
+    std::vector<AliasSummaryYaml> ASums;
     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];
+    io.mapRequired(Key.str().c_str(), GVSums);
+    io.mapRequired(Key.str().c_str(), ASums);
+    auto &Elem = V[Key].Summary;
     for (auto &FSum : FSums) {
-      Elem.SummaryList.push_back(llvm::make_unique<FunctionSummary>(
+      Elem->SummaryList.push_back(llvm::make_unique<FunctionSummary>(
           GlobalValueSummary::GVFlags(
               static_cast<GlobalValue::LinkageTypes>(FSum.Linkage),
               FSum.NotEligibleToImport, FSum.Live),
           0, ArrayRef<ValueInfo>{}, ArrayRef<FunctionSummary::EdgeTy>{},
           std::move(FSum.TypeTests), std::move(FSum.TypeTestAssumeVCalls),
           std::move(FSum.TypeCheckedLoadVCalls),
           std::move(FSum.TypeTestAssumeConstVCalls),
           std::move(FSum.TypeCheckedLoadConstVCalls)));
     }
+
+    for (auto &GVSum : GVSums) {
+      Elem->SummaryList.push_back(llvm::make_unique<GlobalVarSummary>(
+          GlobalValueSummary::GVFlags(
+              static_cast<GlobalValue::LinkageTypes>(GVSum.Linkage),
+              GVSum.NotEligibleToImport, GVSum.Live),
+          ArrayRef<ValueInfo>{}));
+    }
+
+    for (auto &ASum : ASums) {
+      Elem->SummaryList.push_back(llvm::make_unique<AliasSummary>(
+          GlobalValueSummary::GVFlags(
+              static_cast<GlobalValue::LinkageTypes>(ASum.Linkage),
+              ASum.NotEligibleToImport, ASum.Live),
+          ArrayRef<ValueInfo>{}));
+    }
   }
-  static void output(IO &io, GlobalValueSummaryMapTy &V) {
+
+  static void output(IO &io, NamedGlobalValueMap &V) {
     for (auto &P : V) {
       std::vector<FunctionSummaryYaml> FSums;
-      for (auto &Sum : P.second.SummaryList) {
-        if (auto *FSum = dyn_cast<FunctionSummary>(Sum.get()))
+      std::vector<GlobalVarSummaryYaml> GVSums;
+      std::vector<AliasSummaryYaml> ASums;
+      for (auto &Sum : P.second.Summary->SummaryList) {
+        if (auto *FSum = dyn_cast<FunctionSummary>(Sum.get())) {
+          std::vector<CalleeInfoYaml> Calls;
+          for (auto edge : FSum->calls()) {
+            Calls.push_back(
+                {P.second.Index->findOidToValueName(edge.first.getGUID()),
+                 edge.first.getGUID(), edge.second.Hotness});
+          }
           FSums.push_back(FunctionSummaryYaml{
-              FSum->flags().Linkage,
+              P.second.GUID, FSum->getSummaryKind(),
+              static_cast<GlobalValue::LinkageTypes>(FSum->flags().Linkage),
               static_cast<bool>(FSum->flags().NotEligibleToImport),
-              static_cast<bool>(FSum->flags().Live), FSum->type_tests(),
+              static_cast<bool>(FSum->flags().Live),
+
+              FSum->instCount(), Calls, FSum->type_tests(),
               FSum->type_test_assume_vcalls(), FSum->type_checked_load_vcalls(),
               FSum->type_test_assume_const_vcalls(),
               FSum->type_checked_load_const_vcalls()});
         }
+      }
+      for (auto &Sum : P.second.Summary->SummaryList) {
+        if (auto *GVSum = dyn_cast<GlobalVarSummary>(Sum.get()))
+          GVSums.push_back(GlobalVarSummaryYaml{
+              P.second.GUID, GVSum->getSummaryKind(),
+              static_cast<GlobalValue::LinkageTypes>(GVSum->flags().Linkage),
+              static_cast<bool>(GVSum->flags().NotEligibleToImport),
+              static_cast<bool>(GVSum->flags().Live)});
+      }
+      for (auto &Sum : P.second.Summary->SummaryList) {
+        if (auto *ASum = dyn_cast<AliasSummary>(Sum.get()))
+          ASums.push_back(AliasSummaryYaml{
+              P.second.GUID, ASum->getSummaryKind(),
+              static_cast<GlobalValue::LinkageTypes>(ASum->flags().Linkage),
+              static_cast<bool>(ASum->flags().NotEligibleToImport),
+              static_cast<bool>(ASum->flags().Live),
+              P.second.Index->findOidToValueName(
+                  ASum->getAliasee().getOriginalName())});
+      }
       if (!FSums.empty())
-        io.mapRequired(llvm::utostr(P.first).c_str(), FSums);
+        io.mapRequired(P.first.c_str(), FSums);
+      if (!GVSums.empty())
+        io.mapRequired(P.first.c_str(), GVSums);
+      if (!ASums.empty())
+        io.mapRequired(P.first.c_str(), ASums);
     }
   }
 };
 
 template <> struct MappingTraits<ModuleSummaryIndex> {
   static void mapping(IO &io, ModuleSummaryIndex& index) {
-    io.mapOptional("GlobalValueMap", index.GlobalValueMap);
+    NamedGlobalValueMap M;
+    for (gvsummary_iterator i = index.GlobalValueMap.begin();
+         i != index.GlobalValueMap.end(); i++) {
+      std::string name = index.findOidToValueName(i->first);
+      M.insert(std::pair<std::string, struct NGVMValue>(
+          name, NGVMValue{&index, i->first, &i->second}));
+    }
+    io.mapOptional("NamedGlobalValueMap", M);
     io.mapOptional("TypeIdMap", index.TypeIdMap);
     io.mapOptional("WithGlobalValueDeadStripping",
                    index.WithGlobalValueDeadStripping);
   }
 };
 
 } // End yaml namespace
 } // End llvm namespace
 
 #endif

lib/Bitcode/Reader/BitcodeReader.cpp

void ModuleSummaryIndexBitcodeReader::setValueGUID(
     uint64_t ValueID, StringRef ValueName, GlobalValue::LinkageTypes Linkage,
     StringRef SourceFileName) {
   std::string GlobalId =
       GlobalValue::getGlobalIdentifier(ValueName, Linkage, SourceFileName);
   auto ValueGUID = GlobalValue::getGUID(GlobalId);
   auto OriginalNameID = ValueGUID;
   if (GlobalValue::isLocalLinkage(Linkage))
     OriginalNameID = GlobalValue::getGUID(ValueName);
+  TheIndex.addOidToValueName(OriginalNameID, GlobalId);
   if (PrintSummaryGUIDs)
     dbgs() << "GUID " << ValueGUID << "(" << OriginalNameID << ") is "
            << ValueName << "\n";
   ValueIdToValueInfoMap[ValueID] =
       std::make_pair(TheIndex.getOrInsertValueInfo(ValueGUID), OriginalNameID);
 }
 
 // Specialized value symbol table parser used when reading module index

test/tools/llvm-lto2/X86/dump-summary.ll

+; RUN: opt -module-summary %s -o %t.o
+; RUN: llvm-lto2 dump-summary %t.o | egrep 'Kind:\s+GlobalVar'
+; RUN: llvm-lto2 dump-summary %t.o | egrep 'Kind:\s+Function'
+; RUN: llvm-lto2 dump-summary %t.o | egrep 'Kind:\s+Alias'
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+@G = constant i32 2048, align 4
+@a = weak alias i32, i32* @G
+
+define void @boop() {
+  tail call void @afun()
+  ret void
+}
+
+declare void @afun()
+declare void @testtest()

tools/llvm-dis/llvm-dis.cpp

std::unique_ptr<Module> M =
                                            /*ShouldLazyLoadMetadata=*/true));
   if (MaterializeMetadata)
     ExitOnErr(M->materializeMetadata());
   else
     ExitOnErr(M->materializeAll());
   return M;
 }
 
+void printModuleSummaryIndex(raw_ostream &Out, const ModuleSummaryIndex *S) {
+  Out << "; Module summary:\n";
+  for (const_gvsummary_iterator i = S->begin(); i != S->end(); i++) {
+    ValueInfo V = S->getValueInfo(i->first);
+    auto L = V.getSummaryList();
+    for (auto i = L.begin(); i != L.end(); i++) {
+      Out << "; " << S->findOidToValueName((*i)->getOriginalName()) << ": ";
+      switch ((*i)->getSummaryKind()) {
+      case GlobalValueSummary::SummaryKind::AliasKind: {
+        AliasSummary *a = cast<AliasSummary>(i->get());
+        Out << "Alias (aliasee "
+            << S->findOidToValueName(a->getAliasee().getOriginalName())
+            << ")\n";
+      } break;
+      case GlobalValueSummary::SummaryKind::FunctionKind: {
+        Out << "Function";
+        FunctionSummary *f = cast<FunctionSummary>(i->get());
+        Out << " (" << f->instCount() << " instruction"
+            << (f->instCount() == 1 ? "" : "s") << ")\n";
+        for (FunctionSummary::EdgeTy c : f->calls()) {
+          Out << ";  called by: " << S->findOidToValueName(c.first.getGUID())
+              << "\n";
+        }
+      } break;
+      case GlobalValueSummary::SummaryKind::GlobalVarKind:
+        Out << "Global Variable\n";
+        break;
+      }
+      const std::string LinkageTypeStr[] = {
+          "external", "available external", "link once any", "link once odr",
+          "weak any", "weak odr",           "appending",     "internal",
+          "private",  "external weak",      "common"};
+      Out << ";  " << LinkageTypeStr[(*i)->flags().Linkage] << " linkage \n";
+    }
+  }
+}
+
 int main(int argc, char **argv) {
   // Print a stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal(argv[0]);
   PrettyStackTraceProgram X(argc, argv);
 
   ExitOnErr.setBanner(std::string(argv[0]) + ": error: ");
 
   LLVMContext Context;
if (EC) {
     return 1;
   }
 
   std::unique_ptr<AssemblyAnnotationWriter> Annotator;
   if (ShowAnnotations)
     Annotator.reset(new CommentWriter());
 
   // All that llvm-dis does is write the assembly to a file.
-  if (!DontPrint)
+  if (!DontPrint) {
     M->print(Out->os(), Annotator.get(), PreserveAssemblyUseListOrder);
 
+    std::unique_ptr<ModuleSummaryIndex> MSI =
+        ExitOnErr(getModuleSummaryIndexForFile(InputFilename));
+    printModuleSummaryIndex(Out->os(), MSI.get());
+  }
+
   // Declare success.
   Out->keep();
 
   return 0;
 }

tools/llvm-lto2/llvm-lto2.cpp

 // link-time optimization according to the provided symbol resolutions using the
 // resolution-based LTO interface, and outputs one or more object files.
 //
 // This program is intended to eventually replace llvm-lto which uses the legacy
 // LTO interface.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/LTO/Caching.h"
+#include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/CodeGen/CommandFlags.h"
 #include "llvm/IR/DiagnosticPrinter.h"
+#include "llvm/IR/ModuleSummaryIndexYAML.h"
+#include "llvm/LTO/Caching.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/Threading.h"
 
 using namespace llvm;
 using namespace lto;

 template <typename T> static T check(ErrorOr<T> E, std::string Msg) {
   if (E)
     return std::move(*E);
   check(E.getError(), Msg);
   return T();
 }
 
 static int usage() {
-  errs() << "Available subcommands: dump-symtab run\n";
+  errs() << "Available subcommands: dump-symtab dump-summary run\n";
   return 1;
 }
 
 static int run(int argc, char **argv) {
   cl::ParseCommandLineOptions(argc, argv, "Resolution-based LTO test harness");
 
   // FIXME: Workaround PR30396 which means that a symbol can appear
   // more than once if it is defined in module-level assembly and
for (StringRef F : make_range(argv + 1, argv + argc)) {
     }
 
     outs() << '\n';
   }
 
   return 0;
 }
 
+static int dumpSummary(int argc, char **argv) {
+  for (StringRef F : make_range(argv + 1, argv + argc)) {
+    std::unique_ptr<MemoryBuffer> MB = check(MemoryBuffer::getFile(F), F);
+    std::unique_ptr<ModuleSummaryIndex> Index =
+        check(getModuleSummaryIndex(*MB), F);
+
+    yaml::Output Out(outs());
+    Out << *Index;
+  }
+
+  return 0;
+}
+
 int main(int argc, char **argv) {
   InitializeAllTargets();
   InitializeAllTargetMCs();
   InitializeAllAsmPrinters();
   InitializeAllAsmParsers();
 
   // FIXME: This should use llvm::cl subcommands, but it isn't currently
   // possible to pass an argument not associated with a subcommand to a
   // subcommand (e.g. -use-new-pm).
   if (argc < 2)
     return usage();
 
   StringRef Subcommand = argv[1];
   // Ensure that argv[0] is correct after adjusting argv/argc.
   argv[1] = argv[0];
   if (Subcommand == "dump-symtab")
     return dumpSymtab(argc - 1, argv + 1);
+  if (Subcommand == "dump-summary")
+    return dumpSummary(argc - 1, argv + 1);
   if (Subcommand == "run")
     return run(argc - 1, argv + 1);
   return usage();
 }