Don't rerun diagnostic passes on deserialized SIL.

Author: atrick

lib/SILOptimizer/IPO/CapturePromotion.cpp

@@ -1306,6 +1306,9 @@ class CapturePromotionPass : public SILModuleTransform {
   void run() override {
     SmallVector<SILFunction*, 128> Worklist;
     for (auto &F : *getModule()) {
+      if (F.wasDeserializedCanonical())
+        continue;
+
       processFunction(&F, Worklist);
     }
 

lib/SILOptimizer/Mandatory/ConstantPropagation.cpp

@@ -46,6 +46,8 @@ class ConstantPropagation : public SILFunctionTransform {
 } // end anonymous namespace
 
 SILTransform *swift::createDiagnosticConstantPropagation() {
+  // Diagostic propagation is rerun on deserialized SIL because it is sensitive
+  // to assert configuration.
   return new ConstantPropagation(true /*enable diagnostics*/);
 }
 

lib/SILOptimizer/Mandatory/DataflowDiagnostics.cpp

@@ -120,6 +120,10 @@ class EmitDFDiagnostics : public SILFunctionTransform {
 
   /// The entry point to the transformation.
   void run() override {
+    // Don't rerun diagnostics on deserialized functions.
+    if (getFunction()->wasDeserializedCanonical())
+      return;
+
     SILModule &M = getFunction()->getModule();
     for (auto &BB : *getFunction())
       for (auto &I : BB) {

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -2963,6 +2963,10 @@ class DefiniteInitialization : public SILFunctionTransform {
 
   /// The entry point to the transformation.
   void run() override {
+    // Don't rerun diagnostics on deserialized functions.
+    if (getFunction()->wasDeserializedCanonical())
+      return;
+
     // Walk through and promote all of the alloc_box's that we can.
     if (checkDefiniteInitialization(*getFunction())) {
       invalidateAnalysis(SILAnalysis::InvalidationKind::FunctionBody);

lib/SILOptimizer/Mandatory/DiagnoseUnreachable.cpp

@@ -793,6 +793,10 @@ void swift::performSILDiagnoseUnreachable(SILModule *M) {
 namespace {
 class NoReturnFolding : public SILFunctionTransform {
   void run() override {
+    // Don't rerun diagnostics on deserialized functions.
+    if (getFunction()->wasDeserializedCanonical())
+      return;
+
     performNoReturnFunctionProcessing(*getFunction(), this);
   }
   };
@@ -804,6 +808,8 @@ SILTransform *swift::createNoReturnFolding() {
 
 
 namespace {
+// This pass reruns on deserialized SIL because diagnostic constant propagation
+// can expose unreachable blocks which are then removed by this pass.
 class DiagnoseUnreachable : public SILFunctionTransform {
   void run() override {
     diagnoseUnreachable(*getFunction());

lib/SILOptimizer/Mandatory/GuaranteedARCOpts.cpp

@@ -205,6 +205,9 @@ bool GuaranteedARCOptsVisitor::visitReleaseValueInst(ReleaseValueInst *RVI) {
 
 namespace {
 
+// Even though this is a mandatory pass, it is rerun after deserialization in
+// cast DiagnosticConstantPropagation exposed anything new in this assert
+// configutation.
 struct GuaranteedARCOpts : SILFunctionTransform {
   void run() override {
     GuaranteedARCOptsVisitor Visitor;

lib/SILOptimizer/Mandatory/MandatoryInlining.cpp

@@ -603,6 +603,19 @@ runOnFunctionRecursively(SILFunction *F, FullApplySite AI,
 //===----------------------------------------------------------------------===//
 
 namespace {
+/// MandatoryInlining reruns on deserialized functions for two reasons, both
+/// unrelated to mandatory inlining:
+///
+/// 1. It recursively visits the entire call tree rooted at transparent
+/// functions. This has the effect of linking all reachable functions. If they
+/// aren't linked until the explicit SILLinker pass, then they don't benefit
+/// from rerunning optimizations like PredictableMemOps. Ideally we wouldn't
+/// need to rerun PredictableMemOps and wouldn't need to eagerly link anything
+/// in the mandatory pipeline.
+///
+/// 2. It may devirtualize non-transparent methods. It's not clear whether we
+/// really need to devirtualize this early without actually inlining, but it can
+/// unblock other optimizations in the mandatory pipeline.
 class MandatoryInlining : public SILModuleTransform {
   /// The entry point to the transformation.
   void run() override {
@@ -614,7 +627,6 @@ class MandatoryInlining : public SILModuleTransform {
     ImmutableFunctionSet::Factory SetFactory;
 
     for (auto &F : *M) {
-      
       // Don't inline into thunks, even transparent callees.
       if (F.isThunk())
         continue;

lib/SILOptimizer/Mandatory/PredictableMemOpt.cpp

@@ -1394,6 +1394,12 @@ namespace {
 
 class PredictableMemoryOptimizations : public SILFunctionTransform {
   /// The entry point to the transformation.
+  ///
+  /// FIXME: This pass should not need to rerun on deserialized
+  /// functions. Nothing should have changed in the upstream pipeline after
+  /// deserialization. However, rerunning does improve some benchmarks. This
+  /// either indicates that this pass missing some opportunities the first time,
+  /// or has a pass order dependency on other early passes.
   void run() override {
     if (optimizeMemoryAllocations(*getFunction()))
       invalidateAnalysis(SILAnalysis::InvalidationKind::FunctionBody);

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -91,6 +91,10 @@ static void addMandatoryOptPipeline(SILPassPipelinePlan &P,
   P.addOwnershipModelEliminator();
   P.addMandatoryInlining();
   P.addPredictableMemoryOptimizations();
+
+  // Diagnostic ConstantPropagation must be rerun on deserialized functions
+  // because it is sensitive to the assert configuration.
+  // Consequently, certain optimization passes beyond this point will also rerun.
   P.addDiagnosticConstantPropagation();
   P.addGuaranteedARCOpts();
   P.addDiagnoseUnreachable();

lib/SILOptimizer/Transforms/AllocBoxToStack.cpp

@@ -944,6 +944,10 @@ namespace {
 class AllocBoxToStack : public SILFunctionTransform {
   /// The entry point to the transformation.
   void run() override {
+    // Don't rerun on deserialized functions. Nothing should have changed.
+    if (getFunction()->wasDeserializedCanonical())
+      return;
+
     AllocBoxToStackState pass(this);
     for (auto &BB : *getFunction()) {
       for (auto &I : BB)

lib/SILOptimizer/Transforms/MarkUninitializedFixup.cpp

@@ -74,6 +74,10 @@ namespace {
 
 struct MarkUninitializedFixup : SILFunctionTransform {
   void run() override {
+    // Don't rerun on deserialized functions. Nothing should have changed.
+    if (getFunction()->wasDeserializedCanonical())
+      return;
+
     bool MadeChange = false;
     for (auto &BB : *getFunction()) {
       for (auto II = BB.begin(), IE = BB.end(); II != IE;) {