[ThinLTO] Show preserved symbols in DOT files

[evgeny777]

Summary

Can be useful for debugging sometimes.

[tejohnson]

lgtm

llvm/include/llvm/IR/ModuleSummaryIndex.h

public:
 
   /// Print to an output stream.
   void print(raw_ostream &OS, bool IsForDebug = false) const;
 
   /// Dump to stderr (for debugging).
   void dump() const;
 
   /// Export summary to dot file for GraphViz.
-  void exportToDot(raw_ostream& OS) const;
+  void
+  exportToDot(raw_ostream &OS,
+              const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols) const;
 
   /// Print out strongly connected components for debugging.
   void dumpSCCs(raw_ostream &OS);
 
   /// Analyze index and detect unmodified globals
   void propagateAttributes(const DenseSet<GlobalValue::GUID> &PreservedSymbols);
 
   /// Checks if we can import global variable from another module.

llvm/include/llvm/LTO/Config.h

struct Config {
   /// combined (ThinLTO-specific). It can be used to implement -save-temps for
   /// the combined index.
   ///
   /// If this function returns false, any further processing for ThinLTO tasks
   /// is aborted.
   ///
   /// It is called regardless of whether the backend is in-process, although it
   /// is not called from individual backend processes.
-  using CombinedIndexHookFn =
-      std::function<bool(const ModuleSummaryIndex &Index)>;
+  using CombinedIndexHookFn = std::function<bool(
+      const ModuleSummaryIndex &Index,
+      const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols)>;
   CombinedIndexHookFn CombinedIndexHook;
 
   /// This is a convenience function that configures this Config object to write
   /// temporary files named after the given OutputFileName for each of the LTO
   /// phases to disk. A client can use this function to implement -save-temps.
   ///
   /// FIXME: Temporary files derived from ThinLTO backends are currently named
   /// after the input file name, rather than the output file name, when

llvm/lib/Analysis/ModuleSummaryAnalysis.cpp

ModuleSummaryIndex llvm::buildModuleSummaryIndex(
   }
 
   if (!ModuleSummaryDotFile.empty()) {
     std::error_code EC;
     raw_fd_ostream OSDot(ModuleSummaryDotFile, EC, sys::fs::OpenFlags::OF_None);
     if (EC)
       report_fatal_error(Twine("Failed to open dot file ") +
                          ModuleSummaryDotFile + ": " + EC.message() + "\n");
-    Index.exportToDot(OSDot);
+    Index.exportToDot(OSDot, {});
   }
 
   return Index;
 }
 
 AnalysisKey ModuleSummaryIndexAnalysis::Key;
 
 ModuleSummaryIndex

llvm/lib/IR/ModuleSummaryIndex.cpp

 }
 
 static bool hasWriteOnlyFlag(const GlobalValueSummary *S) {
   if (auto *GVS = dyn_cast<GlobalVarSummary>(S))
     return GVS->maybeWriteOnly();
   return false;
 }
 
-void ModuleSummaryIndex::exportToDot(raw_ostream &OS) const {
+void ModuleSummaryIndex::exportToDot(
+    raw_ostream &OS,
+    const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols) const {
   std::vector<Edge> CrossModuleEdges;
   DenseMap<GlobalValue::GUID, std::vector<uint64_t>> NodeMap;
   using GVSOrderedMapTy = std::map<GlobalValue::GUID, GlobalValueSummary *>;
   std::map<StringRef, GVSOrderedMapTy> ModuleToDefinedGVS;
   collectDefinedGVSummariesPerModule(ModuleToDefinedGVS);
 
   // Get node identifier in form MXXX_<GUID>. The MXXX prefix is required,
   // because we may have multiple linkonce functions summaries.
for (auto &SummaryIt : GVSMap) {
           A.addComment("immutable");
         if (Flags.Live && hasWriteOnlyFlag(SummaryIt.second))
           A.addComment("writeOnly");
       }
       if (Flags.DSOLocal)
         A.addComment("dsoLocal");
       if (Flags.CanAutoHide)
         A.addComment("canAutoHide");
+      if (GUIDPreservedSymbols.count(SummaryIt.first))
+        A.addComment("preserved");
 
       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");
 

llvm/lib/LTO/LTO.cpp

ThinBackend lto::createWriteIndexesThinBackend(
   };
 }
 
 Error LTO::runThinLTO(AddStreamFn AddStream, NativeObjectCache Cache,
                       const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols) {
   if (ThinLTO.ModuleMap.empty())
     return Error::success();
 
-  if (Conf.CombinedIndexHook && !Conf.CombinedIndexHook(ThinLTO.CombinedIndex))
+  if (Conf.CombinedIndexHook &&
+      !Conf.CombinedIndexHook(ThinLTO.CombinedIndex, GUIDPreservedSymbols))
     return Error::success();
 
   // Collect for each module the list of function it defines (GUID ->
   // Summary).
   StringMap<GVSummaryMapTy>
       ModuleToDefinedGVSummaries(ThinLTO.ModuleMap.size());
   ThinLTO.CombinedIndex.collectDefinedGVSummariesPerModule(
       ModuleToDefinedGVSummaries);

llvm/lib/LTO/LTOBackend.cpp

Error Config::addSaveTemps(std::string OutputFileName,
 
   setHook("0.preopt", PreOptModuleHook);
   setHook("1.promote", PostPromoteModuleHook);
   setHook("2.internalize", PostInternalizeModuleHook);
   setHook("3.import", PostImportModuleHook);
   setHook("4.opt", PostOptModuleHook);
   setHook("5.precodegen", PreCodeGenModuleHook);
 
-  CombinedIndexHook = [=](const ModuleSummaryIndex &Index) {
+  CombinedIndexHook =
+      [=](const ModuleSummaryIndex &Index,
+          const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols) {
         std::string Path = OutputFileName + "index.bc";
         std::error_code EC;
         raw_fd_ostream OS(Path, EC, sys::fs::OpenFlags::OF_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::OF_None);
         if (EC)
           reportOpenError(Path, EC.message());
-    Index.exportToDot(OSDot);
+        Index.exportToDot(OSDot, GUIDPreservedSymbols);
         return true;
       };
 
   return Error::success();
 }
 
 namespace {
 
 std::unique_ptr<TargetMachine>
 createTargetMachine(Config &Conf, const Target *TheTarget, Module &M) {

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

 ; COMBINED:     digraph Summary {
 ; COMBINED-NEXT:  // Module: {{.*}}dot-dumper{{.*}}1.bc
 ; COMBINED-NEXT:  subgraph cluster_0 {
 ; COMBINED-NEXT:    style = filled;
 ; COMBINED-NEXT:    color = lightgrey;
 ; COMBINED-NEXT:    label = "dot-dumper{{.*}}1.bc";
 ; COMBINED-NEXT:    node [style=filled,fillcolor=lightblue];
 ; COMBINED-NEXT:    M0_[[MAIN_ALIAS:[0-9]+]] [style="dotted,filled",shape="box",label="main_alias",fillcolor="red"]; // alias, dead
-; COMBINED-NEXT:    M0_[[MAIN:[0-9]+]] [shape="record",label="main|extern (inst: 4, ffl: 000000)}"]; // function
+; COMBINED-NEXT:    M0_[[MAIN:[0-9]+]] [shape="record",label="main|extern (inst: 4, ffl: 000000)}"]; // function, preserved
 ; COMBINED-NEXT:    // Edges:
 ; COMBINED-NEXT:    M0_[[MAIN_ALIAS]] -> M0_[[MAIN]] [style=dotted]; // alias
 ; COMBINED-NEXT:  }
 ; COMBINED-NEXT:  // Module: {{.*}}dot-dumper{{.*}}2.bc
 ; COMBINED-NEXT:  subgraph cluster_1 {
 ; COMBINED-NEXT:    style = filled;
 ; COMBINED-NEXT:    color = lightgrey;
 ; COMBINED-NEXT:    label = "dot-dumper{{.*}}2.bc";