Add PruneVTables to the performance optimizer passes.

Author: jckarter

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -663,6 +663,8 @@ static void addLastChanceOptPassPipeline(SILPassPipelinePlan &P) {
 
   // Only has an effect if opt-remark is enabled.
   P.addOptRemarkGenerator();
+
+  P.addPruneVTables();
 }
 
 static void addSILDebugInfoGeneratorPipeline(SILPassPipelinePlan &P) {

lib/SILOptimizer/Transforms/PruneVTables.cpp

@@ -20,6 +20,9 @@
 #include "swift/SILOptimizer/PassManager/Transforms.h"
 #include "swift/SILOptimizer/Utils/InstOptUtils.h"
 
+STATISTIC(NumNonoverriddenVTableEntries,
+          "# of vtable entries marked non-overridden");
+
 using namespace swift;
 
 namespace {
@@ -61,6 +64,7 @@ class PruneVTables : public SILModuleTransform {
         if (methodDecl->isOverridden())
           continue;
       }
+      ++NumNonoverriddenVTableEntries;
       entry.setNonOverridden(true);
     }
   }

test/IRGen/vtable_non_overridden.sil

@@ -66,3 +66,18 @@ sil_vtable InternalB {
 // CHECK-NOT:      @InternalA_foo
 // CHECK-SAME:     @InternalB_bar
 // CHECK-NOT:      @InternalA_bas
+
+// CHECK-LABEL: define {{.*}}@non_overridable_invocation
+sil @non_overridable_invocation : $@convention(thin) (@guaranteed InternalA, @guaranteed InternalB) -> () {
+entry(%a : $InternalA, %b : $InternalB):
+  // CHECK: call swiftcc void @InternalA_foo
+  %am = class_method %a : $InternalA, #InternalA.foo, $@convention(method) (@guaranteed InternalA) -> ()
+  apply %am(%a) : $@convention(method) (@guaranteed InternalA) -> ()
+
+  // CHECK: call swiftcc void @InternalA_foo
+  %bm = class_method %b : $InternalB, #InternalA.foo, $@convention(method) (@guaranteed InternalA) -> ()
+  %ba = upcast %b : $InternalB to $InternalA
+  apply %bm(%ba) : $@convention(method) (@guaranteed InternalA) -> ()
+
+  return undef : $()
+}

test/SILOptimizer/prune-vtables.sil

@@ -34,6 +34,15 @@ private class PrivateB: PrivateA {
 
 sil @PrivateB_yesOverrides : $@convention(method) (@guaranteed PrivateB) -> ()
 
+// NOWMO-LABEL: sil_vtable PrivateB {
+// NOWMO:         #PrivateA.noOverrides{{.*}} [nonoverridden]
+// NOWMO-NOT:     #PrivateA.yesOverrides{{.*}} [nonoverridden]
+// NOWMO:         #PrivateA.isFinal{{.*}} [nonoverridden]
+
+// WMO-LABEL: sil_vtable PrivateB {
+// WMO:         #PrivateA.noOverrides{{.*}} [nonoverridden]
+// WMO-NOT:     #PrivateA.yesOverrides{{.*}} [nonoverridden]
+// WMO:         #PrivateA.isFinal{{.*}} [nonoverridden]
 sil_vtable PrivateB {
   #PrivateA.noOverrides:  @PrivateA_noOverrides  [inherited]
   #PrivateA.yesOverrides: @PrivateB_yesOverrides [override]
@@ -71,6 +80,15 @@ internal class InternalB: InternalA {
 
 sil @InternalB_yesOverrides : $@convention(method) (@guaranteed InternalB) -> ()
 
+// NOWMO-LABEL: sil_vtable InternalB {
+// NOWMO-NOT:     #InternalA.noOverrides{{.*}} [nonoverridden]
+// NOWMO-NOT:     #InternalA.yesOverrides{{.*}} [nonoverridden]
+// NOWMO:         #InternalA.isFinal{{.*}} [nonoverridden]
+
+// WMO-LABEL: sil_vtable InternalB {
+// WMO:         #InternalA.noOverrides{{.*}} [nonoverridden]
+// WMO-NOT:     #InternalA.yesOverrides{{.*}} [nonoverridden]
+// WMO:         #InternalA.isFinal{{.*}} [nonoverridden]
 sil_vtable InternalB {
   #InternalA.noOverrides:  @InternalA_noOverrides  [inherited]
   #InternalA.yesOverrides: @InternalB_yesOverrides [override]
@@ -108,6 +126,15 @@ public class PublicB: PublicA {
 
 sil @PublicB_yesOverrides : $@convention(method) (@guaranteed PublicB) -> ()
 
+// NOWMO-LABEL: sil_vtable PublicB {
+// NOWMO-NOT:     #PublicA.noOverrides{{.*}} [nonoverridden]
+// NOWMO-NOT:     #PublicA.yesOverrides{{.*}} [nonoverridden]
+// NOWMO:         #PublicA.isFinal{{.*}} [nonoverridden]
+
+// WMO-LABEL: sil_vtable PublicB {
+// WMO:         #PublicA.noOverrides{{.*}} [nonoverridden]
+// WMO-NOT:     #PublicA.yesOverrides{{.*}} [nonoverridden]
+// WMO:         #PublicA.isFinal{{.*}} [nonoverridden]
 sil_vtable PublicB {
   #PublicA.noOverrides:  @PublicA_noOverrides  [inherited]
   #PublicA.yesOverrides: @PublicB_yesOverrides [override]
@@ -145,6 +172,15 @@ open class OpenB: OpenA {
 
 sil @OpenB_yesOverrides : $@convention(method) (@guaranteed OpenB) -> ()
 
+// NOWMO-LABEL: sil_vtable OpenB {
+// NOWMO-NOT:     #OpenA.noOverrides{{.*}} [nonoverridden]
+// NOWMO-NOT:     #OpenA.yesOverrides{{.*}} [nonoverridden]
+// NOWMO:         #OpenA.isFinal{{.*}} [nonoverridden]
+
+// WMO-LABEL: sil_vtable OpenB {
+// WMO-NOT:     #OpenA.noOverrides{{.*}} [nonoverridden]
+// WMO-NOT:     #OpenA.yesOverrides{{.*}} [nonoverridden]
+// WMO:         #OpenA.isFinal{{.*}} [nonoverridden]
 sil_vtable OpenB {
   #OpenA.noOverrides:  @PublicA_noOverrides [inherited]
   #OpenA.yesOverrides: @OpenB_yesOverrides  [override]