Add a stand-alone generic specializer pass.

Begin unbundling devirtualization, specialization, and inlining by
recreating the stand-alone generic specializer pass.

I've added a use of the pass to the pipeline, but this is almost
certainly not going to be the final location of where it runs. It's
primarily there to ensure this code gets exercised.

Since this is running prior to inlining, it changes the order that some
functions are specialized in, which means differences in the order of
output of one of the tests (one which similarly changed when
devirtualization, specialization, and inlining were bundled together).

Author: rudkx

include/swift/SILOptimizer/PassManager/Passes.def

@@ -104,6 +104,8 @@ PASS(RedundantLoadElimination, "redundant-load-elim",
      "Multiple basic block redundant load elimination")
 PASS(DeadStoreElimination, "dead-store-elim",
      "Multiple basic block dead store elimination")
+PASS(GenericSpecializer, "generic-specializer",
+     "Specialization of generic functions by static types")
 PASS(GlobalOpt, "global-opt",
      "Global variable optimizations")
 PASS(GlobalPropertyOpt, "global-property-opt",

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -277,16 +277,12 @@ void SILPassManager::runFunctionPasses(PassList FuncTransforms) {
     runPassesOnFunction(FuncTransforms, F);
 
     ++CountOptimized[F];
-    // We currently have no function passes that generate new
-    // functions, so confirm that we only optimize a given function
-    // once.
-    assert(CountOptimized[F] == 1 && "Expected function to be optimized once!");
 
     // If running the function transforms did not result in new
     // functions being added to the top of the worklist, then we're
-    // done with this function and can pop it off and
-    // continue. Otherwise, we'll return to this function and
-    // reoptimize after processing the new function that were added.
+    // done with this function and can pop it off and continue.
+    // Otherwise, we'll return to this function and reoptimize after
+    // processing the new functions that were added.
     if (F == FunctionWorklist.back())
       FunctionWorklist.pop_back();
   }

lib/SILOptimizer/PassManager/Passes.cpp

@@ -251,6 +251,7 @@ void swift::runSILOptimizationPasses(SILModule &Module) {
 
   // Run two iterations of the high-level SSA passes.
   PM.setStageName("HighLevel");
+  PM.addGenericSpecializer();
   AddSSAPasses(PM, OptimizationLevelKind::HighLevel);
   PM.runOneIteration();
   PM.runOneIteration();

lib/SILOptimizer/Transforms/CMakeLists.txt

@@ -7,6 +7,7 @@ set(TRANSFORMS_SOURCES
   Transforms/DeadCodeElimination.cpp
   Transforms/DeadObjectElimination.cpp
   Transforms/DeadStoreElimination.cpp
+  Transforms/GenericSpecializer.cpp
   Transforms/MergeCondFail.cpp
   Transforms/RedundantLoadElimination.cpp
   Transforms/RedundantOverflowCheckRemoval.cpp

lib/SILOptimizer/Transforms/GenericSpecializer.cpp

@@ -0,0 +1,123 @@
+//===-- GenericSpecializer.cpp - Specialization of generic functions ------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Specialize calls to generic functions by substituting static type
+// information.
+//
+//===----------------------------------------------------------------------===//
+
+#define DEBUG_TYPE "sil-generic-specialize"
+
+#include "swift/SIL/SILFunction.h"
+#include "swift/SIL/SILInstruction.h"
+#include "swift/SILOptimizer/Utils/Generics.h"
+#include "swift/SILOptimizer/Utils/Local.h"
+#include "swift/SILOptimizer/PassManager/Transforms.h"
+#include "llvm/ADT/SmallVector.h"
+
+using namespace swift;
+
+// STATISTIC(NumEscapingAllocas, "Number of aggregate allocas not chopped up "
+//           "due to uses.");
+// STATISTIC(NumChoppedAllocas, "Number of chopped up aggregate allocas.");
+// STATISTIC(NumUnhandledAllocas, "Number of non struct, tuple allocas.");
+
+namespace {} // end anonymous namespace
+
+namespace {
+
+class GenericSpecializer : public SILFunctionTransform {
+
+  bool specializeAppliesInFunction(SILFunction &F);
+
+  /// The entry point to the transformation.
+  void run() override {
+    SILFunction &F = *getFunction();
+    DEBUG(llvm::dbgs() << "***** GenericSpecializer on function:" << F.getName()
+                       << " *****\n");
+
+    if (specializeAppliesInFunction(F))
+      invalidateAnalysis(SILAnalysis::InvalidationKind::FunctionBody);
+  }
+
+  StringRef getName() override { return "Generic Specializer"; }
+};
+
+} // end anonymous namespace
+
+bool GenericSpecializer::specializeAppliesInFunction(SILFunction &F) {
+  bool Changed = false;
+  llvm::SmallVector<SILInstruction *, 8> DeadApplies;
+
+  for (auto &BB : F) {
+    for (auto It = BB.begin(), End = BB.end(); It != End;) {
+      auto &I = *It++;
+
+      // Skip non-apply instructions, apply instructions with no
+      // substitutions, apply instructions where we do not statically
+      // know the called function, and apply instructions where we do
+      // not have the body of the called function.
+
+      ApplySite Apply = ApplySite::isa(&I);
+      if (!Apply || !Apply.hasSubstitutions())
+        continue;
+
+      auto *Callee = Apply.getCalleeFunction();
+      if (!Callee || !Callee->isDefinition())
+        continue;
+
+      // We have a call that can potentially be specialized, so
+      // attempt to do so.
+
+      // The specializer helper function currently expects a collector
+      // argument, but we aren't going to make use of the results so
+      // we'll have our filter always return false;
+      auto Filter = [](SILInstruction *I) -> bool { return false; };
+      CloneCollector Collector(Filter);
+
+      SILFunction *SpecializedFunction;
+
+      auto Specialized =
+          trySpecializeApplyOfGeneric(Apply, SpecializedFunction, Collector);
+
+      if (Specialized) {
+        Changed = true;
+
+        // If calling the specialization utility resulted in a new
+        // function (as opposed to returning a previous
+        // specialization), we need to notify the pass manager so that
+        // the new function gets optimized.
+        if (SpecializedFunction)
+          notifyPassManagerOfFunction(SpecializedFunction);
+
+        auto *AI = Apply.getInstruction();
+
+        if (!isa<TryApplyInst>(AI))
+          AI->replaceAllUsesWith(Specialized.getInstruction());
+
+        DeadApplies.push_back(AI);
+      }
+    }
+  }
+
+  // Remove all the now-dead applies.
+  while (!DeadApplies.empty()) {
+    auto *AI = DeadApplies.pop_back_val();
+    recursivelyDeleteTriviallyDeadInstructions(AI, true);
+  }
+
+  return Changed;
+}
+
+SILTransform *swift::createGenericSpecializer() {
+  return new GenericSpecializer();
+}

test/SILOptimizer/specialize_inherited.sil

@@ -1,4 +1,4 @@
-// RUN: %target-sil-opt -enable-sil-verify-all %s -inline -module-name inherit | FileCheck %s
+// RUN: %target-sil-opt -enable-sil-verify-all %s -generic-specializer -module-name inherit | FileCheck %s
 
 import Builtin
 import Swift

test/SILOptimizer/specialize_metatypes_with_nondefault_representation.sil

@@ -1,4 +1,4 @@
-// RUN: %target-sil-opt -enable-sil-verify-all %s -inline | FileCheck %s
+// RUN: %target-sil-opt -enable-sil-verify-all %s -generic-specializer | FileCheck %s
 
 // REQUIRES: objc_interop