Remove GPE pass implementation. (#24418)

Author: pschuh

include/swift/SILOptimizer/PassManager/Passes.def

@@ -283,20 +283,6 @@ PASS(SwiftArrayOpts, "array-specialize",
 // SWIFT_ENABLE_TENSORFLOW
 PASS(Differentiation, "differentiation",
      "Automatic Differentiation")
-PASS(TFDeabstractionMandatory, "tf-deabstraction-mandatory",
-     "Deabstract tensor operations")
-PASS(TFDeabstractionOpt, "tf-deabstraction-opt",
-     "Deabstract tensor operations")
-PASS(TFPartitionMandatory, "tf-partition-mandatory",
-     "Partition accelerator operations out of mainline control flow")
-PASS(TFPartitionOpt, "tf-partition-opt",
-     "Partition accelerator operations out of mainline control flow")
-PASS(TFPartitionTest, "tf-partition",
-     "Partition accelerator operations out of mainline control flow")
-PASS(TFXLACFGCanonicalize, "tf-xla-cfg-canonicalize",
-     "Canonicalize the control flow graph into SESE region for XLA")
-PASS(TFLowerGraph, "tf-lower-graph",
-     "Lower the given control flow graph into a TF graph")
 // SWIFT_ENABLE_TENSORFLOW End
 PASS(UnsafeGuaranteedPeephole, "unsafe-guaranteed-peephole",
      "SIL retain/release Peephole Removal for Builtin.unsafeGuaranteed")

lib/SILOptimizer/Mandatory/CMakeLists.txt

@@ -21,11 +21,5 @@ silopt_register_sources(
   RawSILInstLowering.cpp
   MandatoryOptUtils.cpp
   # SWIFT_ENABLE_TENSORFLOW
-  TFCanonicalizeCFG.cpp
   TFConstExpr.cpp
-  TFDeabstraction.cpp
-  TFDevicePartition.cpp
-  TFLowerGraph.cpp
-  TFPartition.cpp
-  TFUtilities.cpp
 )

lib/SILOptimizer/Mandatory/MandatoryInlining.cpp

@@ -25,18 +25,13 @@
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/ImmutableSet.h"
 #include "llvm/ADT/Statistic.h"
-// SWIFT_ENABLE_TENSORFLOW
-#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 
 using namespace swift;
 
 using DenseFunctionSet = llvm::DenseSet<SILFunction *>;
 using ImmutableFunctionSet = llvm::ImmutableSet<SILFunction *>;
 
-// SWIFT_ENABLE_TENSORFLOW
-extern llvm::cl::opt<bool> TFLogDeabstractionStats;
-
 STATISTIC(NumMandatoryInlines,
           "Number of function application sites inlined by the mandatory "
           "inlining pass");
@@ -306,9 +301,7 @@ static void collectPartiallyAppliedArguments(
 static SILFunction *getCalleeFunction(
     SILFunction *F, FullApplySite AI, bool &IsThick,
     SmallVectorImpl<std::pair<SILValue, ParameterConvention>> &CaptureArgs,
-    SmallVectorImpl<SILValue> &FullArgs, PartialApplyInst *&PartialApply,
-    // SWIFT_ENABLE_TENSORFLOW
-    const ShouldMandatoryInlineFnPred &shouldInlinePredicate) {
+    SmallVectorImpl<SILValue> &FullArgs, PartialApplyInst *&PartialApply) {
   IsThick = false;
   PartialApply = nullptr;
   CaptureArgs.clear();
@@ -454,11 +447,17 @@ static SILFunction *getCalleeFunction(
     return nullptr;
   }
 
-  // TODO(SR-8015): `shouldInlinePredicate` does too much. Fix this.
   // If the CalleeFunction is a not-transparent definition, we can not process
   // it.
-  // SWIFT_ENABLE_TENSORFLOW
-  if (!shouldInlinePredicate(AI, *CalleeFunction))
+  if (CalleeFunction->isTransparent() == IsNotTransparent)
+    return nullptr;
+
+  // If CalleeFunction is a declaration, see if we can load it.
+  if (CalleeFunction->empty())
+    AI.getModule().loadFunction(CalleeFunction);
+
+  // If we fail to load it, bail.
+  if (CalleeFunction->empty())
     return nullptr;
 
   if (F->isSerialized() &&
@@ -492,20 +491,6 @@ tryDevirtualizeApplyHelper(FullApplySite InnerAI, SILBasicBlock::iterator I,
                          newApplyAI->getIterator());
 }
 
-// SWIFT_ENABLE_TENSORFLOW
-// Event schema:
-//
-// "S4TF CallEdge", ParentName, ParentSizeBefore, ParentSizeAfter, ChildName,
-// ChildSize
-static void maybeLogCallEdge(SILFunction *parent, unsigned parentSizeBefore,
-                             SILFunction *child) {
-  if (!TFLogDeabstractionStats)
-    return;
-  llvm::dbgs() << "S4TF CallEdge," << parent->getName() << ","
-               << parentSizeBefore << "," << parent->codeSize() << ","
-               << child->getName() << "," << child->codeSize() << "\n";
-}
-
 /// \brief Inlines all mandatory inlined functions into the body of a function,
 /// first recursively inlining all mandatory apply instructions in those
 /// functions into their bodies if necessary.
@@ -520,14 +505,13 @@ static void maybeLogCallEdge(SILFunction *parent, unsigned parentSizeBefore,
 ///   the current call stack of recursive calls
 ///
 /// \returns true if successful, false if failed due to circular inlining.
-static bool runOnFunctionRecursively(
-    SILOptFunctionBuilder &FuncBuilder, SILFunction *F, FullApplySite AI,
-    DenseFunctionSet &FullyInlinedSet,
-    ImmutableFunctionSet::Factory &SetFactory,
-    ImmutableFunctionSet CurrentInliningSet, ClassHierarchyAnalysis *CHA,
-    // SWIFT_ENABLE_TENSORFLOW
-    SILInliner::InlineKind inlineKind,
-    const ShouldMandatoryInlineFnPred &shouldInlinePredicate) {
+static bool
+runOnFunctionRecursively(SILOptFunctionBuilder &FuncBuilder,
+			 SILFunction *F, FullApplySite AI,
+                         DenseFunctionSet &FullyInlinedSet,
+                         ImmutableFunctionSet::Factory &SetFactory,
+                         ImmutableFunctionSet CurrentInliningSet,
+                         ClassHierarchyAnalysis *CHA) {
   // Avoid reprocessing functions needlessly.
   if (FullyInlinedSet.count(F))
     return true;
@@ -574,18 +558,15 @@ static bool runOnFunctionRecursively(
       bool IsThick;
       PartialApplyInst *PAI;
       SILFunction *CalleeFunction = getCalleeFunction(
-          F, InnerAI, IsThick, CaptureArgs, FullArgs, PAI,
-          shouldInlinePredicate);  // SWIFT_ENABLE_TENSORFLOW
+          F, InnerAI, IsThick, CaptureArgs, FullArgs, PAI);
 
       if (!CalleeFunction)
         continue;
 
       // Then recursively process it first before trying to inline it.
       if (!runOnFunctionRecursively(FuncBuilder, CalleeFunction, InnerAI,
                                     FullyInlinedSet, SetFactory,
-                                    CurrentInliningSet, CHA,
-                                    // SWIFT_ENABLE_TENSORFLOW
-                                    inlineKind, shouldInlinePredicate)) {
+                                    CurrentInliningSet, CHA)) {
         // If we failed due to circular inlining, then emit some notes to
         // trace back the failure if we have more information.
         // FIXME: possibly it could be worth recovering and attempting other
@@ -616,10 +597,8 @@ static bool runOnFunctionRecursively(
         OpenedArchetypesTracker.registerUsedOpenedArchetypes(PAI);
       }
 
-      // SWIFT_ENABLE_TENSORFLOW
-      unsigned parentSizeBefore = F->codeSize();
-      SILInliner Inliner(FuncBuilder, inlineKind, Subs,
-                         OpenedArchetypesTracker);
+      SILInliner Inliner(FuncBuilder, SILInliner::InlineKind::MandatoryInline,
+                         Subs, OpenedArchetypesTracker);
       if (!Inliner.canInlineApplySite(InnerAI)) {
         // See comment above about casting when devirtualizing and how this
         // sometimes causes II and InnerAI to be different and even in different
@@ -666,9 +645,6 @@ static bool runOnFunctionRecursively(
       assert(nextI == ApplyBlock->end()
              || nextI->getParent() == ApplyBlock
                     && "Mismatch between the instruction and basic block");
-
-      // SWIFT_ENABLE_TENSORFLOW
-      maybeLogCallEdge(F, parentSizeBefore, CalleeFunction);
     }
   }
 
@@ -678,29 +654,6 @@ static bool runOnFunctionRecursively(
   return true;
 }
 
-// SWIFT_ENABLE_TENSORFLOW
-/// Scan the given function body, mandatory inlining calls to callees that
-/// satisfy the specified predicate, including calls sites exposed by inlining
-/// other functions.
-///
-/// The deabstraction phase of TensorFlow support needs to mandatory inline
-/// certain functions using the standard mandatory inlining algorithm.  This
-/// function implements support for it, inlining direct calls to callees that
-/// satisfy the given predicate.
-void swift::inlineForTFDeabstraction(SILOptFunctionBuilder &FB, SILFunction &fn,
-                                 const ShouldMandatoryInlineFnPred &predicate) {
-  DenseFunctionSet FullyInlinedSet;
-  ImmutableFunctionSet::Factory SetFactory;
-
-  runOnFunctionRecursively(FB, &fn,
-                           FullApplySite(static_cast<ApplyInst*>(nullptr)),
-                           FullyInlinedSet,
-                           SetFactory, SetFactory.getEmptySet(),
-                           /*CHA*/nullptr,
-                           SILInliner::InlineKind::PerformanceInline,
-                           predicate);
-}
-
 //===----------------------------------------------------------------------===//
 //                          Top Level Driver
 //===----------------------------------------------------------------------===//
@@ -726,24 +679,9 @@ class MandatoryInlining : public SILModuleTransform {
       if (F.wasDeserializedCanonical())
         continue;
 
-      // SWIFT_ENABLE_TENSORFLOW
       runOnFunctionRecursively(FuncBuilder, &F,
-                               FullApplySite(),
-                               FullyInlinedSet,
-                               SetFactory, SetFactory.getEmptySet(), CHA,
-                               SILInliner::InlineKind::MandatoryInline,
-         [&](FullApplySite site, SILFunction &callee) -> bool {
-           if (callee.isTransparent() != IsTransparent)
-             return false;
-
-           // If CalleeFunction is a declaration, see if we can load it.
-           if (callee.empty())
-             site.getModule().loadFunction(&callee);
-
-           // If we failed to load it, bail.
-           return !callee.empty();
-         }
-       );
+                               FullApplySite(), FullyInlinedSet, SetFactory,
+                               SetFactory.getEmptySet(), CHA);
     }
 
     if (!ShouldCleanup)