[ownership] Do some preliminary work for moving OME out of the diagnostics pipeline.

This disables a bunch of passes when ownership is enabled. This will allow me to
keep transparent functions in ossa and skip most of the performance pipeline without
being touched by passes that have not been updated for ownership.

This is important so that we can in -Onone code import transparent functions and
inline them into other ossa functions (you can't inline from ossa => non-ossa).

Author: gottesmm

lib/SILOptimizer/ARC/ARCSequenceOpts.cpp

@@ -265,10 +265,15 @@ class ARCSequenceOpts : public SILFunctionTransform {
   /// The entry point to the transformation.
   void run() override {
     auto *F = getFunction();
+
     // If ARC optimizations are disabled, don't optimize anything and bail.
     if (!getOptions().EnableARCOptimizations)
       return;
 
+    // FIXME: We should support ownership.
+    if (F->hasOwnership())
+      return;
+
     if (!EnableLoopARC) {
       auto *AA = getAnalysis<AliasAnalysis>();
       auto *POTA = getAnalysis<PostOrderAnalysis>();

lib/SILOptimizer/FunctionSignatureTransforms/ExistentialSpecializer.cpp

@@ -63,14 +63,17 @@ class ExistentialSpecializer : public SILFunctionTransform {
   ClassHierarchyAnalysis *CHA;
 public:
   void run() override {
-
     auto *F = getFunction();
 
     /// Don't optimize functions that should not be optimized.
     if (!F->shouldOptimize() || !F->getModule().getOptions().ExistentialSpecializer) {
       return;
     }
 
+    // FIXME: This pass should be able to support ownership.
+    if (F->hasOwnership())
+      return;
+
     /// Get CallerAnalysis information handy.
     CA = PM->getAnalysis<CallerAnalysis>();
 

lib/SILOptimizer/IPO/LetPropertiesOpts.cpp

@@ -581,6 +581,9 @@ void LetPropertiesOpt::run(SILModuleTransform *T) {
     // properties.
     bool NonRemovable = !F.shouldOptimize();
 
+    // FIXME: We should be able to handle ownership.
+    NonRemovable &= !F.hasOwnership();
+
     for (auto &BB : F) {
       for (auto &I : BB)
         // Look for any instructions accessing let properties.

lib/SILOptimizer/LoopTransforms/ArrayBoundsCheckOpts.cpp

@@ -1288,6 +1288,9 @@ class ABCOpt : public SILFunctionTransform {
 
     SILFunction *F = getFunction();
     assert(F);
+    // FIXME: Update for ownership.
+    if (F->hasOwnership())
+      return;
     SILLoopInfo *LI = LA->get(F);
     assert(LI);
     DominanceInfo *DT = DA->get(F);

lib/SILOptimizer/LoopTransforms/COWArrayOpt.cpp

@@ -1160,6 +1160,10 @@ namespace {
 
 class COWArrayOptPass : public SILFunctionTransform {
   void run() override {
+    // FIXME: Update for ownership.
+    if (getFunction()->hasOwnership())
+      return;
+
     LLVM_DEBUG(llvm::dbgs() << "COW Array Opts in Func "
                             << getFunction()->getName() << "\n");
 
@@ -1847,6 +1851,10 @@ class SwiftArrayOptPass : public SILFunctionTransform {
 
     auto *Fn = getFunction();
 
+    // FIXME: Add support for ownership.
+    if (Fn->hasOwnership())
+      return;
+
     // Don't hoist array property calls at Osize.
     if (Fn->optimizeForSize())
       return;

lib/SILOptimizer/LoopTransforms/LoopRotate.cpp

@@ -421,6 +421,10 @@ class LoopRotation : public SILFunctionTransform {
 
     SILFunction *F = getFunction();
     assert(F);
+    // FIXME: Add ownership support.
+    if (F->hasOwnership())
+      return;
+
     SILLoopInfo *LI = LA->get(F);
     assert(LI);
     DominanceInfo *DT = DA->get(F);

lib/SILOptimizer/Mandatory/GuaranteedARCOpts.cpp

@@ -229,6 +229,10 @@ namespace {
 // configuration.
 struct GuaranteedARCOpts : SILFunctionTransform {
   void run() override {
+    // Skip ownership SIL. We are going to have a run of semantic arc opts here.
+    if (getFunction()->hasOwnership())
+      return;
+
     GuaranteedARCOptsVisitor Visitor;
 
     bool MadeChange = false;

lib/SILOptimizer/SILCombiner/SILCombine.cpp

@@ -345,6 +345,10 @@ class SILCombine : public SILFunctionTransform {
 
   /// The entry point to the transformation.
   void run() override {
+    // FIXME: We should be able to handle ownership.
+    if (getFunction()->hasOwnership())
+      return;
+
     auto *AA = PM->getAnalysis<AliasAnalysis>();
     auto *DA = PM->getAnalysis<DominanceAnalysis>();
     auto *PCA = PM->getAnalysis<ProtocolConformanceAnalysis>();

lib/SILOptimizer/Transforms/ARCCodeMotion.cpp

@@ -1151,6 +1151,10 @@ class ARCCodeMotion : public SILFunctionTransform {
     if (!F->shouldOptimize())
       return;
 
+    // FIXME: Support ownership.
+    if (F->hasOwnership())
+      return;
+
     LLVM_DEBUG(llvm::dbgs() << "*** ARCCM on function: " << F->getName()
                             << " ***\n");
 

lib/SILOptimizer/Transforms/AccessEnforcementOpts.cpp

@@ -1130,6 +1130,10 @@ struct AccessEnforcementOpts : public SILFunctionTransform {
     if (F->empty())
       return;
 
+    // FIXME: Support ownership.
+    if (F->hasOwnership())
+      return;
+
     LLVM_DEBUG(llvm::dbgs() << "Running local AccessEnforcementOpts on "
                             << F->getName() << "\n");