[caller-analysis] Change the dumping format to be a yaml format and update tests to use that format.

The current dumping format consists of 1 row of information per function. This
will become unweildy to write patterns for when I add additional state to
FunctionInfo.

Instead, this commit converts the dumping format of the caller analysis into a
multi line yaml format. This yaml format looks as follows:

  ---
  calleeName:      closure1
  hasCaller:       false
  minPartialAppliedArgs: 1
  partialAppliers:
    - partial_apply_one_arg
    - partial_apply_two_args1
  fullAppliers:
  ...

This can easily expand over time as we expand the queries that caller analysis
can answer.

As an additional advantage, there are definitely yaml parsers that can handle
multiple yaml documents in sequence in a stream. This means that by running via
sil-opt the caller-analysis-printer pass, one now will get a yaml description of
the caller analysis state, perfect and ready for analysis.

Author: gottesmm

include/swift/SILOptimizer/Analysis/CallerAnalysis.h

@@ -119,12 +119,28 @@ class CallerAnalysis : public SILAnalysis {
   /// Notify the analysis about changed witness or vtables.
   virtual void invalidateFunctionTables() override { }
 
-  const FunctionInfo &getCallerInfo(SILFunction *F) {
+  const FunctionInfo &getCallerInfo(SILFunction *F) const {
     // Recompute every function in the invalidated function list and empty the
     // list.
-    processRecomputeFunctionList();
-    return FuncInfos[F];
+    auto *self = const_cast<CallerAnalysis *>(this);
+    self->processRecomputeFunctionList();
+    return self->FuncInfos[F];
   }
+
+#ifndef NDEBUG
+  LLVM_ATTRIBUTE_DEPRECATED(void dump() const LLVM_ATTRIBUTE_USED,
+                            "Only for use in the debugger");
+#endif
+
+  /// Print the state of the caller analysis as a sequence of yaml documents for
+  /// each callee we are tracking.
+  void print(llvm::raw_ostream &os) const;
+
+  /// Print the state of the caller analysis as a sequence of yaml documents for
+  /// each callee we are tracking to the passed in file path.
+  LLVM_ATTRIBUTE_DEPRECATED(void print(const char *filePath)
+                                const LLVM_ATTRIBUTE_USED,
+                            "Only for use in the debugger");
 };
 
 /// NOTE: this can be extended to contain the callsites of the function.

lib/SILOptimizer/Analysis/CallerAnalysis.cpp

@@ -14,9 +14,15 @@
 
 #include "swift/SIL/SILModule.h"
 #include "swift/SILOptimizer/Utils/Local.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/YAMLTraits.h"
 
 using namespace swift;
 
+//===----------------------------------------------------------------------===//
+//                              Actual Analysis
+//===----------------------------------------------------------------------===//
+
 void CallerAnalysis::processFunctionCallSites(SILFunction *F) {
   // Scan the whole module and search Apply sites.
   for (auto &BB : *F) {
@@ -53,8 +59,8 @@ void CallerAnalysis::processFunctionCallSites(SILFunction *F) {
         }
         continue;
       }
-    }   
-  }   
+    }
+  }
 }
 
 void CallerAnalysis::invalidateExistingCalleeRelation(SILFunction *F) {
@@ -66,9 +72,107 @@ void CallerAnalysis::invalidateExistingCalleeRelation(SILFunction *F) {
   }
 }
 
+//===----------------------------------------------------------------------===//
+//                         CallerAnalysis YAML Dumper
+//===----------------------------------------------------------------------===//
+
+namespace {
+
+using llvm::yaml::IO;
+using llvm::yaml::MappingTraits;
+using llvm::yaml::Output;
+using llvm::yaml::ScalarEnumerationTraits;
+using llvm::yaml::SequenceTraits;
+
+/// A special struct that marshals call graph state into a form that is easy for
+/// llvm's yaml i/o to dump. Its structure is meant to correspond to how the
+/// data should be shown by the printer, so naturally it is slightly redundant.
+struct YAMLCallGraphNode {
+  StringRef calleeName;
+  bool hasCaller;
+  unsigned minPartialAppliedArgs;
+  std::vector<StringRef> partialAppliers;
+  std::vector<StringRef> fullAppliers;
+
+  YAMLCallGraphNode() = delete;
+  ~YAMLCallGraphNode() = default;
+
+  // This is a data structure that can not be copied or moved.
+  YAMLCallGraphNode(const YAMLCallGraphNode &) = delete;
+  YAMLCallGraphNode(YAMLCallGraphNode &&) = delete;
+  YAMLCallGraphNode &operator=(const YAMLCallGraphNode &) = delete;
+  YAMLCallGraphNode &operator=(YAMLCallGraphNode &&) = delete;
+
+  YAMLCallGraphNode(StringRef calleeName, bool hasCaller,
+                    unsigned minPartialAppliedArgs,
+                    std::vector<StringRef> &&partialAppliers,
+                    std::vector<StringRef> &&fullAppliers)
+      : calleeName(calleeName), hasCaller(hasCaller),
+        minPartialAppliedArgs(minPartialAppliedArgs),
+        partialAppliers(std::move(partialAppliers)),
+        fullAppliers(std::move(fullAppliers)) {}
+};
+
+} // end anonymous namespace
+
+namespace llvm {
+namespace yaml {
+
+template <> struct MappingTraits<YAMLCallGraphNode> {
+  static void mapping(IO &io, YAMLCallGraphNode &func) {
+    io.mapRequired("calleeName", func.calleeName);
+    io.mapRequired("hasCaller", func.hasCaller);
+    io.mapRequired("minPartialAppliedArgs", func.minPartialAppliedArgs);
+    io.mapRequired("partialAppliers", func.partialAppliers);
+    io.mapRequired("fullAppliers", func.fullAppliers);
+  }
+};
+
+} // namespace yaml
+} // namespace llvm
+
+void CallerAnalysis::dump() const { print(llvm::errs()); }
+
+void CallerAnalysis::print(const char *filePath) const {
+  using namespace llvm::sys;
+  std::error_code error;
+  llvm::raw_fd_ostream fileOutputStream(filePath, error, fs::F_Text);
+  if (error) {
+    llvm::errs() << "Failed to open path \"" << filePath << "\" for writing.!";
+    llvm_unreachable("default error handler");
+  }
+  print(fileOutputStream);
+}
+
+void CallerAnalysis::print(llvm::raw_ostream &os) const {
+  llvm::yaml::Output yout(os);
+
+  // NOTE: We purposely do not iterate over our internal state here to ensure
+  // that we dump for all functions and that we dump the state we have stored
+  // with the functions in module order.
+  for (auto &f : Mod) {
+    const auto &fi = getCallerInfo(&f);
+
+    std::vector<StringRef> fullAppliers;
+    for (auto *caller : fi.Callers) {
+      fullAppliers.push_back(caller->getName());
+    }
+    std::vector<StringRef> partialAppliers;
+    for (auto iter : fi.PartialAppliers) {
+      partialAppliers.push_back(iter.first->getName());
+    }
+
+    YAMLCallGraphNode node(f.getName(), fi.hasCaller(),
+                           fi.getMinPartialAppliedArgs(),
+                           std::move(partialAppliers), std::move(fullAppliers));
+    yout << node;
+  }
+}
+
 //===----------------------------------------------------------------------===//
 //                              Main Entry Point
 //===----------------------------------------------------------------------===//
+
 SILAnalysis *swift::createCallerAnalysis(SILModule *M) {
   return new CallerAnalysis(M);
 }

lib/SILOptimizer/UtilityPasses/CallerAnalysisPrinter.cpp

@@ -14,10 +14,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "swift/SILOptimizer/Analysis/CallerAnalysis.h"
 #include "swift/SIL/SILFunction.h"
 #include "swift/SIL/SILModule.h"
+#include "swift/SILOptimizer/Analysis/CallerAnalysis.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
+#include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace swift;
@@ -26,19 +27,15 @@ using namespace swift;
 
 namespace {
 
+/// A pass that dumps the caller analysis state in yaml form. Intended to allow
+/// for visualizing of the caller analysis via external data visualization and
+/// analysis programs.
 class CallerAnalysisPrinterPass : public SILModuleTransform {
   /// The entry point to the transformation.
   void run() override {
     auto *CA = getAnalysis<CallerAnalysis>();
-    for (auto &F : *getModule()) {
-      const CallerAnalysis::FunctionInfo &FI = CA->getCallerInfo(&F);
-      const char *hasCaller = FI.hasCaller() ? "true" : "false";
-      llvm::outs() << "Function " << F.getName() << " has caller: "
-                   << hasCaller << ", partial applied args = "
-                   << FI.getMinPartialAppliedArgs() << "\n";
-    }
+    CA->print(llvm::outs());
   }
-
 };
 
 } // end anonymous namespace