DeadFunctionElimination: Also eliminate dead global variables.

eeckstein · eeckstein · commit ee8cdac501e4 · 2021-02-09T19:56:43.000+01:00
It makes sense to to this in a single pass, because there might be dead cycles for globals and functions, e.g. if a global references a function in its static initializer and the function references that global.

Another improvement: eliminate dead global-initializers. Before we had an explicit SIL representation of statically initialized globals, we had to keep them alive.

rdar://32956923
diff --git a/include/swift/SIL/SILGlobalVariable.h b/include/swift/SIL/SILGlobalVariable.h
@@ -128,6 +128,10 @@ class SILGlobalVariable
   SILLinkage getLinkage() const { return SILLinkage(Linkage); }
   void setLinkage(SILLinkage linkage) { Linkage = unsigned(linkage); }
 
+  /// Returns true if the linkage of the SILFunction indicates that the global
+  /// might be referenced from outside the current compilation unit.
+  bool isPossiblyUsedExternally() const;
+
   /// Get this global variable's serialized attribute.
   IsSerialized_t isSerialized() const;
   void setSerialized(IsSerialized_t isSerialized);
diff --git a/lib/SIL/IR/SILGlobalVariable.cpp b/lib/SIL/IR/SILGlobalVariable.cpp
@@ -62,6 +62,11 @@ SILGlobalVariable::~SILGlobalVariable() {
   StaticInitializerBlock.clearStaticInitializerBlock(Module);
 }
 
+bool SILGlobalVariable::isPossiblyUsedExternally() const {
+  SILLinkage linkage = getLinkage();
+  return swift::isPossiblyUsedExternally(linkage, getModule().isWholeModule());
+}
+
 /// Get this global variable's fragile attribute.
 IsSerialized_t SILGlobalVariable::isSerialized() const {
   return Serialized ? IsSerialized : IsNotSerialized;
diff --git a/lib/SILOptimizer/IPO/DeadFunctionElimination.cpp b/lib/SILOptimizer/IPO/DeadFunctionElimination.cpp
@@ -27,6 +27,7 @@
 using namespace swift;
 
 STATISTIC(NumDeadFunc, "Number of dead functions eliminated");
+STATISTIC(NumDeadGlobals, "Number of dead global variables eliminated");
 
 namespace {
 
@@ -115,11 +116,6 @@ class FunctionLivenessComputation {
     if (F->getRepresentation() == SILFunctionTypeRepresentation::ObjCMethod)
       return true;
 
-    // Global initializers are always emitted into the defining module and
-    // their bodies are never SIL serialized.
-    if (F->isGlobalInit())
-      return true;
-
     return false;
   }
 
@@ -145,6 +141,11 @@ class FunctionLivenessComputation {
     return AliveFunctionsAndTables.count(WT) != 0;
   }
 
+  /// Returns true if a global variable is marked as alive.
+  bool isAlive(SILGlobalVariable *global) {
+    return AliveFunctionsAndTables.count(global) != 0;
+  }
+
   /// Marks a function as alive.
   void makeAlive(SILFunction *F) {
     AliveFunctionsAndTables.insert(F);
@@ -204,6 +205,16 @@ class FunctionLivenessComputation {
     }
   }
 
+  /// Marks the \p global and all functions, which are referenced from its
+  /// initializer as alive.
+  void makeAlive(SILGlobalVariable *global) {
+    AliveFunctionsAndTables.insert(global);
+    for (const SILInstruction &initInst : *global) {
+      if (auto *fRef = dyn_cast<FunctionRefInst>(&initInst))
+        ensureAlive(fRef->getReferencedFunction());
+    }
+  }
+
   /// Marks the declarations referenced by a key path pattern as alive if they
   /// aren't yet.
   void
@@ -239,6 +250,12 @@ class FunctionLivenessComputation {
       makeAlive(F);
   }
 
+  /// Marks a global variable as alive if it is not alive yet.
+  void ensureAlive(SILGlobalVariable *global) {
+    if (!isAlive(global))
+      makeAlive(global);
+  }
+
   /// Marks a witness table as alive if it is not alive yet.
   void ensureAliveConformance(const ProtocolConformance *C) {
     SILWitnessTable *WT = Module->lookUpWitnessTable(C,
@@ -342,6 +359,10 @@ class FunctionLivenessComputation {
         } else if (auto *KPI = dyn_cast<KeyPathInst>(&I)) {
           for (auto &component : KPI->getPattern()->getComponents())
             ensureKeyPathComponentIsAlive(component);
+        } else if (auto *GA = dyn_cast<GlobalAddrInst>(&I)) {
+          ensureAlive(GA->getReferencedGlobal());
+        } else if (auto *GV = dyn_cast<GlobalValueInst>(&I)) {
+          ensureAlive(GV->getReferencedGlobal());
         }
       }
     }
@@ -407,6 +428,11 @@ class FunctionLivenessComputation {
         ensureAlive(&F);
       }
     }
+    
+    for (SILGlobalVariable &global : Module->getSILGlobals()) {
+      if (global.isPossiblyUsedExternally())
+        ensureAlive(&global);
+    }
   }
 
 public:
@@ -675,13 +701,21 @@ class DeadFunctionElimination : FunctionLivenessComputation {
 
     // First drop all references so that we don't get problems with non-zero
     // reference counts of dead functions.
-    std::vector<SILFunction *> DeadFunctions;
+    llvm::SmallVector<SILFunction *, 16> DeadFunctions;
+    llvm::SmallVector<SILGlobalVariable *, 16> DeadGlobals;
     for (SILFunction &F : *Module) {
       if (!isAlive(&F)) {
         F.dropAllReferences();
         DeadFunctions.push_back(&F);
       }
     }
+    
+    for (SILGlobalVariable &global : Module->getSILGlobals()) {
+      if (!isAlive(&global)) {
+        global.dropAllReferences();
+        DeadGlobals.push_back(&global);
+      }
+    }
 
     // Next step: delete dead witness tables.
     SILModule::WitnessTableListType &WTables = Module->getWitnessTableList();
@@ -706,6 +740,11 @@ class DeadFunctionElimination : FunctionLivenessComputation {
       DFEPass->notifyWillDeleteFunction(F);
       Module->eraseFunction(F);
     }
+    for (SILGlobalVariable *deadGlobal : DeadGlobals) {
+      ++NumDeadGlobals;
+      Module->eraseGlobalVariable(deadGlobal);
+    }
+    
     if (changedTables)
       DFEPass->invalidateFunctionTables();
   }
diff --git a/test/SILOptimizer/dead_function_elimination.swift b/test/SILOptimizer/dead_function_elimination.swift
@@ -168,19 +168,39 @@ internal func donotEliminate() {
   return
 }
 
+func callingGlobalFuncPtr() {
+  GFStr.globalFuncPtr()
+}
+
+func aliveReferencedFunc() {
+}
+
+struct GFStr {
+  static var globalFuncPtr: () -> () = callingGlobalFuncPtr
+  static var aliveFuncPtr: () -> () = aliveReferencedFunc
+}
+
+public func keepPtrAlive() {
+  GFStr.aliveFuncPtr()
+}
+
 // CHECK-NOT: sil {{.*}}inCycleA
 // CHECK-NOT: sil {{.*}}inCycleB
 // CHECK-NOT: sil {{.*}}DeadMethod
 // CHECK-NOT: sil {{.*}}DeadWitness
 // CHECK-NOT: sil {{.*}}publicClassMethod
+// CHECK-NOT: sil {{.*}}callingGlobalFuncPtr
+// CHECK-NOT: sil_global {{.*}}globalFuncPtr
 
 // CHECK-TESTING: sil {{.*}}inCycleA
 // CHECK-TESTING: sil {{.*}}inCycleB
 // CHECK-TESTING: sil {{.*}}DeadMethod
 // CHECK-TESTING: sil {{.*}}publicClassMethod
 // CHECK-TESTING: sil {{.*}}DeadWitness
 
+// CHECK-LABEL: sil_global hidden @$s25dead_function_elimination5GFStrV12aliveFuncPtryycvpZ
 // CHECK-LABEL: @$s25dead_function_elimination14donotEliminateyyF
+// CHECK-LABEL: sil @$s25dead_function_elimination12keepPtrAliveyyF
 
 // CHECK-LABEL: sil_vtable Base
 // CHECK: aliveMethod
diff --git a/test/SILOptimizer/remove_unused_func.sil b/test/SILOptimizer/remove_unused_func.sil
@@ -1,3 +1,4 @@
+// RUN: %target-sil-opt -enable-sil-verify-all %s -sil-deadfuncelim | %FileCheck --check-prefix=KEEP %s
 // RUN: %target-sil-opt -enable-sil-verify-all %s -sil-deadfuncelim | %FileCheck %s
 
 sil_stage canonical
@@ -6,7 +7,7 @@ import Builtin
 import Swift
 
 // This function needs to be removed.
-// CHECK-NOT: @remove_me
+// KEEP-NOT: @remove_me
 
 sil private @remove_me : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
 bb0(%0 : $Builtin.Int64):
@@ -15,3 +16,32 @@ bb0(%0 : $Builtin.Int64):
   %4 = tuple_extract %3 : $(Builtin.Int64, Builtin.Int1), 0
   return %4: $Builtin.Int64
 }
+
+sil_global @globalFunctionPointer : $@callee_guaranteed () -> () = {
+  %0 = function_ref @alivePrivateFunc : $@convention(thin) () -> ()
+  %initval = thin_to_thick_function %0 : $@convention(thin) () -> () to $@callee_guaranteed () -> ()
+}
+
+// CHECK-LABEL: sil private @alivePrivateFunc
+sil private @alivePrivateFunc : $@convention(thin) () -> () {
+bb0:
+  %0 = tuple ()
+  return %0 : $()
+}
+
+// KEEP-NOT: @privateFunctionPointer
+sil_global private @privateFunctionPointer : $@callee_guaranteed () -> () = {
+  %0 = function_ref @deadPrivateFunc : $@convention(thin) () -> ()
+  %initval = thin_to_thick_function %0 : $@convention(thin) () -> () to $@callee_guaranteed () -> ()
+}
+
+// KEEP-NOT: @deadPrivateFunc
+sil private @deadPrivateFunc : $@convention(thin) () -> () {
+bb0:
+  %0 = global_addr @privateFunctionPointer : $*@callee_guaranteed () -> ()
+  %1 = load %0 : $*@callee_guaranteed () -> ()
+  %2 = apply %1() : $@callee_guaranteed () -> ()
+  %3 = tuple ()
+  return %3 : $()
+}
+
diff --git a/test/SILOptimizer/sil_combine_protocol_conf.swift b/test/SILOptimizer/sil_combine_protocol_conf.swift
@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend %s -O -wmo -emit-sil -Xllvm -sil-disable-pass=DeadFunctionElimination | %FileCheck %s
+// RUN: %target-swift-frontend %s -O -wmo -emit-sil | %FileCheck %s
 
 // case 1: class protocol -- should optimize
 internal protocol SomeProtocol : class {
@@ -95,7 +95,7 @@ internal class Klass2: MultipleConformanceProtocol {
 }
 
 
-internal class Other {
+public class Other {
    let x:SomeProtocol
    let y:SomeNonClassProtocol
    let z:DerivedProtocol
@@ -113,7 +113,7 @@ internal class Other {
      self.s = s;
    }
 
-// CHECK-LABEL: sil hidden [noinline] @$s25sil_combine_protocol_conf5OtherC11doWorkClassSiyF : $@convention(method) (@guaranteed Other) -> Int {
+// CHECK-LABEL: sil [noinline] @$s25sil_combine_protocol_conf5OtherC11doWorkClassSiyF : $@convention(method) (@guaranteed Other) -> Int {
 // CHECK: bb0
 // CHECK: debug_value
 // CHECK: integer_literal
@@ -162,7 +162,7 @@ internal class Other {
 // CHECK: struct 
 // CHECK: return
 // CHECK: } // end sil function '$s25sil_combine_protocol_conf5OtherC11doWorkClassSiyF'
-   @inline(never) func doWorkClass () ->Int {
+   @inline(never) public func doWorkClass () ->Int {
       return self.x.foo(x:self.x) // optimize
              + self.y.bar(x:self.y) // optimize
              + self.z.foo() // do not optimize
@@ -221,7 +221,7 @@ struct GenericOuter<T> {
   }
 }
 
-internal class OtherClass {
+public class OtherClass {
   var arg1: PropProtocol
   var arg2: GenericPropProtocol
   var arg3: NestedPropProtocol
@@ -234,7 +234,7 @@ internal class OtherClass {
      self.arg4 = arg4
   }
 
-// CHECK-LABEL: sil hidden [noinline] @$s25sil_combine_protocol_conf10OtherClassC12doWorkStructSiyF : $@convention(method) (@guaranteed OtherClass) -> Int {
+// CHECK-LABEL: sil [noinline] @$s25sil_combine_protocol_conf10OtherClassC12doWorkStructSiyF : $@convention(method) (@guaranteed OtherClass) -> Int {
 // CHECK: bb0([[ARG:%.*]] :
 // CHECK: debug_value
 // CHECK: [[R1:%.*]] = ref_element_addr [[ARG]] : $OtherClass, #OtherClass.arg1
@@ -279,7 +279,7 @@ internal class OtherClass {
 // CHECK: struct
 // CHECK: return
 // CHECK: } // end sil function '$s25sil_combine_protocol_conf10OtherClassC12doWorkStructSiyF'
-  @inline(never) func doWorkStruct () -> Int{
+  @inline(never) public func doWorkStruct () -> Int{
     return self.arg1.val  // optimize
            + self.arg2.val  // do not optimize
            + self.arg3.val  // optimize
@@ -322,7 +322,7 @@ internal enum AGenericEnum<T> : AGenericProtocol {
   }
 }
 
-internal class OtherKlass {
+public class OtherKlass {
   var arg1: AProtocol
   var arg2: AGenericProtocol
 
@@ -331,7 +331,7 @@ internal class OtherKlass {
      self.arg2 = arg2
   }
 
-// CHECK-LABEL: sil hidden [noinline] @$s25sil_combine_protocol_conf10OtherKlassC10doWorkEnumSiyF : $@convention(method) (@guaranteed OtherKlass) -> Int {
+// CHECK-LABEL: sil [noinline] @$s25sil_combine_protocol_conf10OtherKlassC10doWorkEnumSiyF : $@convention(method) (@guaranteed OtherKlass) -> Int {
 // CHECK: bb0([[ARG:%.*]] :
 // CHECK: debug_value
 // CHECK: integer_literal
@@ -350,7 +350,7 @@ internal class OtherKlass {
 // CHECK: struct
 // CHECK: return
 // CHECK: } // end sil function '$s25sil_combine_protocol_conf10OtherKlassC10doWorkEnumSiyF'
-  @inline(never) func doWorkEnum() -> Int {
+  @inline(never) public func doWorkEnum() -> Int {
     return self.arg1.val  // optimize
            + self.arg2.val // do not optimize
   }
