[ownership] Move OME out of the diagnostics pipeline behind a flag.

Once the flag is flipped, ownership stripping will no longer be done in the
diagnostics pipeline. Instead what will happen is that:

* Onone: At -Onone, we run the entire diagnostics pipeline with ownership
enabled and do not strip ownership until after we serialize in the Onone
"optimization" pass pipeline plan.

* -O: At -O, to temporarily work around serialization issues with transparent
functions, we strip ownership from all but transparent functions at the
beginning of the performance pipeline, serialize, and then strip ownership from
transparent functions. For this to work, I needed to make sure that the
performance pipeline passes that do not support ownership SIL, just skip such
functions. So the transparent functions will arrive (mostly) untouched in
serialized SIL and the rest of the pipeline will optimize non-transparent
functions as they should.

The key thing about the -O change is that it /should/ be performance neutral
since after we serialize we re-run the entire pipeline so we can optimize
semantic functions that we only can inline after we serialize.

Author: gottesmm

include/swift/AST/SILOptions.h

@@ -135,6 +135,10 @@ class SILOptions {
   /// Enable large loadable types IRGen pass.
   bool EnableLargeLoadableTypes = true;
 
+  /// Should the default pass pipelines strip ownership during the diagnostic
+  /// pipeline.
+  bool StripOwnershipDuringDiagnosticsPipeline = true;
+
   /// The name of the file to which the backend should save YAML optimization
   /// records.
   std::string OptRecordFile;

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -103,7 +103,8 @@ static void addMandatoryOptPipeline(SILPassPipelinePlan &P) {
     P.addSemanticARCOpts();
   }
   P.addClosureLifetimeFixup();
-  P.addOwnershipModelEliminator();
+  if (Options.StripOwnershipDuringDiagnosticsPipeline)
+    P.addOwnershipModelEliminator();
   P.addMandatoryInlining();
   P.addMandatorySILLinker();
 
@@ -294,6 +295,11 @@ void addSSAPasses(SILPassPipelinePlan &P, OptimizationLevelKind OpLevel) {
     // which reduces the ability of the compiler to optimize clients
     // importing this module.
     P.addSerializeSILPass();
+
+    // Now strip any transparent functions that still have ownership.
+    if (!P.getOptions().StripOwnershipDuringDiagnosticsPipeline)
+      P.addOwnershipModelEliminator();
+
     if (P.getOptions().StopOptimizationAfterSerialization)
       return;
 
@@ -371,6 +377,10 @@ static void addPerfEarlyModulePassPipeline(SILPassPipelinePlan &P) {
   // we do not spend time optimizing them.
   P.addDeadFunctionElimination();
 
+  // Strip ownership from non-transparent functions.
+  if (!P.getOptions().StripOwnershipDuringDiagnosticsPipeline)
+    P.addNonTransparentFunctionOwnershipModelEliminator();
+
   // Start by cloning functions from stdlib.
   P.addPerformanceSILLinker();
 
@@ -643,6 +653,10 @@ SILPassPipelinePlan::getOnonePassPipeline(const SILOptions &Options) {
   // Finally serialize the SIL if we are asked to.
   P.addSerializeSILPass();
 
+  // And then strip ownership before we IRGen.
+  if (!Options.StripOwnershipDuringDiagnosticsPipeline)
+    P.addOwnershipModelEliminator();
+
   return P;
 }