Refactor bottom-up function ordering code from the call graph.

This adds a new utility as well as a test pass for computing the
bottom-up SCC ordering of the functions in the module.

Currently all functions are included, but we could consider in the
future including only those functions that are potentially reachable
from outside the current scope of compilation (module or file depending
on compile mode).

This would allow us to skip optimizing functions that we'll eventually
eliminate.

Author: rudkx

include/swift/SILAnalysis/FunctionOrder.h

@@ -0,0 +1,59 @@
+//===--- FunctionOrder.h - Utilities for function ordering  ----*- C++ -*--===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SILANALYSIS_FUNCTIONORDER_H
+#define SWIFT_SILANALYSIS_FUNCTIONORDER_H
+
+#include "swift/SILAnalysis/BasicCalleeAnalysis.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/TinyPtrVector.h"
+
+namespace swift {
+
+class BasicCalleeAnalysis;
+class SILFunction;
+class SILModule;
+
+class BottomUpFunctionOrder {
+public:
+  typedef TinyPtrVector<SILFunction *> SCC;
+
+private:
+  llvm::SmallVector<SCC, 32> TheSCCs;
+
+  // The callee analysis we use to determine the callees at each call site.
+  BasicCalleeAnalysis *BCA;
+
+  unsigned NextDFSNum;
+  llvm::DenseMap<SILFunction *, unsigned> DFSNum;
+  llvm::DenseMap<SILFunction *, unsigned> MinDFSNum;
+  llvm::SmallSetVector<SILFunction *, 4> DFSStack;
+
+public:
+  BottomUpFunctionOrder(SILModule &M, BasicCalleeAnalysis *BCA)
+      : BCA(BCA), NextDFSNum(0) {
+    FindSCCs(M);
+  }
+
+  ArrayRef<SCC> getBottomUpSCCs() { return TheSCCs; }
+
+private:
+  void DFS(SILFunction *F);
+  void FindSCCs(SILModule &M);
+};
+
+} // end namespace swift
+
+#endif

include/swift/SILPasses/Passes.def

@@ -83,6 +83,8 @@ PASS(ExternalDefsToDecls, "external-defs-to-decls",
      "Convert external definitions to decls")
 PASS(ExternalFunctionDefinitionsElimination, "external-func-definition-elim",
      "Eliminate external function definitions")
+PASS(FunctionOrderPrinter, "function-order-printer",
+     "Print function orderings for test purposes")
 PASS(FunctionSignatureOpts, "function-signature-opts",
      "Optimize Function Signatures")
 PASS(ARCSequenceOpts, "arc-sequence-opts",

lib/SILAnalysis/CMakeLists.txt

@@ -10,6 +10,7 @@ add_swift_library(swiftSILAnalysis
   ColdBlockInfo.cpp
   DestructorAnalysis.cpp
   EscapeAnalysis.cpp
+  FunctionOrder.cpp
   IVAnalysis.cpp
   LoopAnalysis.cpp
   LoopRegionAnalysis.cpp

lib/SILAnalysis/FunctionOrder.cpp

@@ -0,0 +1,80 @@
+//===----- FunctionOrder.cpp - Utility for function ordering --------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/SILAnalysis/FunctionOrder.h"
+#include "swift/SIL/SILBasicBlock.h"
+#include "swift/SIL/SILFunction.h"
+#include "swift/SIL/SILInstruction.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/TinyPtrVector.h"
+#include <algorithm>
+
+using namespace swift;
+
+/// Use Tarjan's strongly connected components (SCC) algorithm to find
+/// the SCCs in the call graph.
+void BottomUpFunctionOrder::DFS(SILFunction *Start) {
+  // Set the DFSNum for this node if we haven't already, and if we
+  // have, which indicates it's already been visited, return.
+  if (!DFSNum.insert(std::make_pair(Start, NextDFSNum)).second)
+    return;
+
+  assert(MinDFSNum.find(Start) == MinDFSNum.end() &&
+         "Function should not already have a minimum DFS number!");
+
+  MinDFSNum[Start] = NextDFSNum;
+  ++NextDFSNum;
+
+  DFSStack.insert(Start);
+
+  // Visit all the instructions, looking for apply sites.
+  for (auto &B : *Start) {
+    for (auto &I : B) {
+      auto FAS = FullApplySite::isa(&I);
+      if (!FAS)
+        continue;
+
+      auto Callees = BCA->getCalleeList(FAS);
+      for (auto *CalleeFn : Callees) {
+        // If not yet visited, visit the callee.
+        if (DFSNum.find(CalleeFn) == DFSNum.end()) {
+          DFS(CalleeFn);
+          MinDFSNum[Start] = std::min(MinDFSNum[Start], MinDFSNum[CalleeFn]);
+        } else if (DFSStack.count(CalleeFn)) {
+          // If the callee is on the stack, it update our minimum DFS
+          // number based on it's DFS number.
+          MinDFSNum[Start] = std::min(MinDFSNum[Start], DFSNum[CalleeFn]);
+        }
+      }
+    }
+  }
+
+  // If our DFS number is the minimum found, we've found a
+  // (potentially singleton) SCC, so pop the nodes off the stack and
+  // push the new SCC on our stack of SCCs.
+  if (DFSNum[Start] == MinDFSNum[Start]) {
+    SCC CurrentSCC;
+
+    SILFunction *Popped;
+    do {
+      Popped = DFSStack.pop_back_val();
+      CurrentSCC.push_back(Popped);
+    } while (Popped != Start);
+
+    TheSCCs.push_back(CurrentSCC);
+  }
+}
+
+void BottomUpFunctionOrder::FindSCCs(SILModule &M) {
+  for (auto &F : M)
+    DFS(&F);
+}

lib/SILPasses/UtilityPasses/CMakeLists.txt

@@ -3,6 +3,7 @@ set(UTILITYPASSES_SOURCES
   UtilityPasses/BasicCalleePrinter.cpp
   UtilityPasses/CFGPrinter.cpp
   UtilityPasses/CallGraphPrinter.cpp
+  UtilityPasses/FunctionOrderPrinter.cpp
   UtilityPasses/IVInfoPrinter.cpp
   UtilityPasses/InstCount.cpp
   UtilityPasses/Link.cpp

lib/SILPasses/UtilityPasses/FunctionOrderPrinter.cpp

@@ -0,0 +1,67 @@
+//===-- FunctionOrderPrinter.cpp - Function ordering test pass ------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass prints a bottom-up ordering of functions in the module (in the
+// sense that each function is printed before functions that call it).
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/SILAnalysis/FunctionOrder.h"
+#include "swift/Basic/DemangleWrappers.h"
+#include "swift/SILAnalysis/BasicCalleeAnalysis.h"
+#include "swift/SIL/SILFunction.h"
+#include "swift/SIL/SILModule.h"
+#include "swift/SILPasses/Transforms.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace swift;
+
+#define DEBUG_TYPE "function-order-printer"
+
+namespace {
+
+class FunctionOrderPrinterPass : public SILModuleTransform {
+  BasicCalleeAnalysis *BCA;
+
+  /// The entry point to the transformation.
+  void run() override {
+    BCA = getAnalysis<BasicCalleeAnalysis>();
+    auto &M = *getModule();
+    BottomUpFunctionOrder Orderer(M, BCA);
+
+    llvm::outs() << "Bottom up function order:\n";
+    auto SCCs = Orderer.getBottomUpSCCs();
+    for (auto &SCC : SCCs) {
+      std::string Indent;
+
+      if (SCC.size() != 1) {
+        llvm::outs() << "Non-trivial SCC:\n";
+        Indent = std::string(2, ' ');
+      }
+
+      for (auto *F : SCC) {
+        llvm::outs() << Indent
+                     << demangle_wrappers::demangleSymbolAsString(F->getName())
+                     << "\n";
+      }
+    }
+    llvm::outs() << "\n";
+  }
+
+  StringRef getName() override { return "Function Order Printer"; }
+};
+
+} // end anonymous namespace
+
+SILTransform *swift::createFunctionOrderPrinter() {
+  return new FunctionOrderPrinterPass();
+}