DeadFunctionElimination: rename the pass and some other refactoring

The main change is to rename DeadFunctionElimination -> DeadFunctionAndGlobalElimination, because the pass is now also doing dead-global elimination.
A second change is to remove the FunctionLivenessComputation base class. It’s not used anywhere else.

Author: eeckstein

include/swift/SILOptimizer/PassManager/Passes.def

@@ -140,8 +140,8 @@ PASS(DCE, "dce",
      "Dead Code Elimination")
 PASS(DeadArgSignatureOpt, "dead-arg-signature-opt",
      "Dead Argument Elimination via Function Specialization")
-PASS(DeadFunctionElimination, "sil-deadfuncelim",
-     "Dead Function Elimination")
+PASS(DeadFunctionAndGlobalElimination, "sil-deadfuncelim",
+     "Dead Function and Global Variable Elimination")
 PASS(DeadObjectElimination, "deadobject-elim",
      "Dead Object Elimination for Classes with Trivial Destruction")
 PASS(DefiniteInitialization, "definite-init",
@@ -220,8 +220,8 @@ PASS(LICM, "licm",
      "Loop Invariant Code Motion")
 PASS(LateCodeMotion, "late-codemotion",
      "Late Code Motion with Release Hoisting")
-PASS(LateDeadFunctionElimination, "late-deadfuncelim",
-     "Late Dead Function Elimination")
+PASS(LateDeadFunctionAndGlobalElimination, "late-deadfuncelim",
+     "Late Dead Function and Global Elimination")
 PASS(LateInliner, "late-inline",
      "Late Function Inlining")
 PASS(LoopCanonicalizer, "loop-canonicalizer",

lib/SILOptimizer/IPO/DeadFunctionElimination.cpp

@@ -1,4 +1,4 @@
-//===--- DeadFunctionElimination.cpp - Eliminate dead functions -----------===//
+//===- DeadFunctionElimination.cpp - Eliminate dead functions and globals -===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -31,12 +31,7 @@ STATISTIC(NumDeadGlobals, "Number of dead global variables eliminated");
 
 namespace {
 
-/// This is a base class for passes that are based on function liveness
-/// computations like e.g. dead function elimination.
-/// It provides a common logic for computing live (i.e. reachable) functions.
-class FunctionLivenessComputation {
-protected:
-
+class DeadFunctionAndGlobalElimination {
   /// Represents a function which is implementing a vtable or witness table
   /// method.
   struct FuncImpl {
@@ -402,9 +397,6 @@ class FunctionLivenessComputation {
     return false;
   }
 
-  /// Find anchors in vtables and witness tables, if required.
-  virtual void findAnchorsInTables() = 0;
-
   /// Find all functions which are alive from the beginning.
   /// For example, functions which may be referenced externally.
   void findAnchors() {
@@ -435,12 +427,6 @@ class FunctionLivenessComputation {
     }
   }
 
-public:
-  FunctionLivenessComputation(SILModule *module,
-                              bool keepExternalWitnessTablesAlive) :
-    Module(module),
-    keepExternalWitnessTablesAlive(keepExternalWitnessTablesAlive) {}
-
   /// The main entry point of the optimization.
   bool findAliveFunctions() {
 
@@ -461,19 +447,6 @@ class FunctionLivenessComputation {
     return false;
   }
 
-  virtual ~FunctionLivenessComputation() {}
-};
-
-} // end anonymous namespace
-
-//===----------------------------------------------------------------------===//
-//                             DeadFunctionElimination
-//===----------------------------------------------------------------------===//
-
-namespace {
-
-class DeadFunctionElimination : FunctionLivenessComputation {
-
   void collectMethodImplementations() {
     // Collect vtable method implementations.
     for (auto &vTable : Module->getVTables()) {
@@ -528,10 +501,9 @@ class DeadFunctionElimination : FunctionLivenessComputation {
     }
   }
 
-  /// DeadFunctionElimination pass takes functions
-  /// reachable via vtables and witness_tables into account
+  /// Take functions reachable via vtables and witness_tables into account
   /// when computing a function liveness information.
-  void findAnchorsInTables() override {
+  void findAnchorsInTables() {
 
     collectMethodImplementations();
 
@@ -688,11 +660,13 @@ class DeadFunctionElimination : FunctionLivenessComputation {
   }
 
 public:
-  DeadFunctionElimination(SILModule *module, bool keepExternalWitnessTablesAlive)
-      : FunctionLivenessComputation(module, keepExternalWitnessTablesAlive) {}
+  DeadFunctionAndGlobalElimination(SILModule *module,
+                                   bool keepExternalWitnessTablesAlive) :
+    Module(module),
+    keepExternalWitnessTablesAlive(keepExternalWitnessTablesAlive) {}
 
   /// The main entry point of the optimization.
-  void eliminateFunctions(SILModuleTransform *DFEPass) {
+  void eliminateFunctionsAndGlobals(SILModuleTransform *DFEPass) {
 
     LLVM_DEBUG(llvm::dbgs() << "running dead function elimination\n");
     findAliveFunctions();
@@ -730,15 +704,12 @@ class DeadFunctionElimination : FunctionLivenessComputation {
     }
 
     // Last step: delete all dead functions.
-    while (!DeadFunctions.empty()) {
-      SILFunction *F = DeadFunctions.back();
-      DeadFunctions.pop_back();
-
-      LLVM_DEBUG(llvm::dbgs() << "  erase dead function " << F->getName()
+    for (SILFunction *deadFunc : DeadFunctions) {
+      LLVM_DEBUG(llvm::dbgs() << "  erase dead function " << deadFunc->getName()
                               << "\n");
       ++NumDeadFunc;
-      DFEPass->notifyWillDeleteFunction(F);
-      Module->eraseFunction(F);
+      DFEPass->notifyWillDeleteFunction(deadFunc);
+      Module->eraseFunction(deadFunc);
     }
     for (SILGlobalVariable *deadGlobal : DeadGlobals) {
       ++NumDeadGlobals;
@@ -758,13 +729,13 @@ class DeadFunctionElimination : FunctionLivenessComputation {
 
 namespace {
 
-class SILDeadFuncElimination : public SILModuleTransform {
+class DeadFunctionAndGlobalEliminationPass : public SILModuleTransform {
 
 private:
   bool isLateDFE;
 
 public:
-  SILDeadFuncElimination(bool isLateDFE) : isLateDFE(isLateDFE) { }
+  DeadFunctionAndGlobalEliminationPass(bool isLateDFE) : isLateDFE(isLateDFE) {}
 
   void run() override {
     LLVM_DEBUG(llvm::dbgs() << "Running DeadFuncElimination\n");
@@ -776,24 +747,25 @@ class SILDeadFuncElimination : public SILModuleTransform {
     // can eliminate such functions.
     getModule()->invalidateSILLoaderCaches();
 
-    DeadFunctionElimination deadFunctionElimination(getModule(),
+    DeadFunctionAndGlobalElimination deadFunctionElimination(getModule(),
                                 /*keepExternalWitnessTablesAlive*/ !isLateDFE);
-    deadFunctionElimination.eliminateFunctions(this);
+    deadFunctionElimination.eliminateFunctionsAndGlobals(this);
   }
 };
 
 } // end anonymous namespace
 
-SILTransform *swift::createDeadFunctionElimination() {
-  return new SILDeadFuncElimination(/*isLateDFE*/ false);
+SILTransform *swift::createDeadFunctionAndGlobalElimination() {
+  return new DeadFunctionAndGlobalEliminationPass(/*isLateDFE*/ false);
 }
 
-SILTransform *swift::createLateDeadFunctionElimination() {
-  return new SILDeadFuncElimination(/*isLateDFE*/ true);
+SILTransform *swift::createLateDeadFunctionAndGlobalElimination() {
+  return new DeadFunctionAndGlobalEliminationPass(/*isLateDFE*/ true);
 }
 
 void swift::performSILDeadFunctionElimination(SILModule *M) {
-  llvm::SmallVector<PassKind, 1> Pass = {PassKind::DeadFunctionElimination};
+  llvm::SmallVector<PassKind, 1> Pass =
+    {PassKind::DeadFunctionAndGlobalElimination};
   auto &opts = M->getOptions();
   auto plan = SILPassPipelinePlan::getPassPipelineForKinds(opts, Pass);
   executePassPipelinePlan(M, plan);

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -451,7 +451,7 @@ static void addPerfEarlyModulePassPipeline(SILPassPipelinePlan &P) {
 
   // Get rid of apparently dead functions as soon as possible so that
   // we do not spend time optimizing them.
-  P.addDeadFunctionElimination();
+  P.addDeadFunctionAndGlobalElimination();
 
   // Cleanup after SILGen: remove trivial copies to temporaries.
   P.addTempRValueOpt();
@@ -525,7 +525,7 @@ static void addHighLevelFunctionPipeline(SILPassPipelinePlan &P) {
 // one round of module passes.
 static void addHighLevelModulePipeline(SILPassPipelinePlan &P) {
   P.startPipeline("HighLevel,Module+StackPromote");
-  P.addDeadFunctionElimination();
+  P.addDeadFunctionAndGlobalElimination();
   P.addPerformanceSILLinker();
   P.addDeadObjectElimination();
   P.addGlobalPropertyOpt();
@@ -572,7 +572,7 @@ static void addMidLevelFunctionPipeline(SILPassPipelinePlan &P) {
 
 static void addClosureSpecializePassPipeline(SILPassPipelinePlan &P) {
   P.startPipeline("ClosureSpecialize");
-  P.addDeadFunctionElimination();
+  P.addDeadFunctionAndGlobalElimination();
   P.addDeadStoreElimination();
   P.addDeadObjectElimination();
 
@@ -639,7 +639,7 @@ static void addLateLoopOptPassPipeline(SILPassPipelinePlan &P) {
   // Delete dead code and drop the bodies of shared functions.
   // Also, remove externally available witness tables. They are not needed
   // anymore after the last devirtualizer run.
-  P.addLateDeadFunctionElimination();
+  P.addLateDeadFunctionAndGlobalElimination();
 
   // Perform the final lowering transformations.
   P.addCodeSinking();

test/SILOptimizer/existential_specializer_indirect_class.sil

@@ -1,4 +1,4 @@
-// RUN: %target-sil-opt -O -wmo -enable-sil-verify-all -sil-disable-pass=DeadFunctionElimination %s | %FileCheck %s
+// RUN: %target-sil-opt -O -wmo -enable-sil-verify-all -sil-disable-pass=DeadFunctionAndGlobalElimination %s | %FileCheck %s
 
 sil_stage canonical