SILGen: Use super_method for native non-final methods in classes

Use the `super_method` instruction for non-final `func` and `class func`
declarations in native Swift classes. Previously, we would always emit
a static `function_ref` for these, which prevents resilient dynamic
dispatch.

This is hidden behind a -use-native-super-dispatch flag while I
survey the effects on devirtualization and stack promotion. When
that's figured out, I'll add more tests and update test cases that
still assume static dispatch.

rdar://problem/22749732

Author: bitjammer

include/swift/AST/SILOptions.h

@@ -97,6 +97,9 @@ class SILOptions {
 
   /// Should we use a pass pipeline passed in via a json file? Null by default.
   StringRef ExternalPassPipelineFilename;
+
+  /// Use super_method for native super method calls instead of function_ref.
+  bool UseNativeSuperMethod = false;
 };
 
 } // end namespace swift

include/swift/Option/FrontendOptions.td

@@ -187,6 +187,9 @@ def dump_clang_diagnostics : Flag<["-"], "dump-clang-diagnostics">,
 def emit_verbose_sil : Flag<["-"], "emit-verbose-sil">,
   HelpText<"Emit locations during SIL emission">;
 
+def use_native_super_method : Flag<["-"], "use-native-super-method">,
+  HelpText<"Use super_method for super calls in native classes">;
+
 def disable_self_type_mangling : Flag<["-"], "disable-self-type-mangling">,
   HelpText<"Disable including Self type in method type manglings">;
 

lib/Frontend/CompilerInvocation.cpp

@@ -1002,6 +1002,8 @@ static bool ParseSILArgs(SILOptions &Opts, ArgList &Args,
 
   Opts.GenerateProfile |= Args.hasArg(OPT_profile_generate);
   Opts.EmitProfileCoverageMapping |= Args.hasArg(OPT_profile_coverage_mapping);
+  Opts.UseNativeSuperMethod |=
+    Args.hasArg(OPT_use_native_super_method);
 
   return false;
 }

lib/SILGen/SILGenApply.cpp

@@ -627,11 +627,12 @@ class Callee {
     case Kind::SuperMethod: {
       assert(level <= Constant.uncurryLevel
              && "uncurrying past natural uncurry level of method");
-      assert(level >= 1
-             && "currying 'self' of super method dispatch not yet supported");
+      assert((level == 0 || level == getNaturalUncurryLevel()) &&
+             "Can only curry self parameter of super method calls");
 
       constant = Constant.atUncurryLevel(level);
       constantInfo = gen.getConstantInfo(*constant);
+
       SILValue methodVal = gen.B.createSuperMethod(Loc,
                                                    SelfValue,
                                                    *constant,
@@ -735,7 +736,10 @@ class Callee {
       return SpecializedEmitter::forDecl(SGM, Constant);
     }
     case Kind::SuperMethod: {
-      return SpecializedEmitter(emitPartialSuperMethod);
+      if (uncurryLevel == 0) {
+        return SpecializedEmitter(emitPartialSuperMethod);
+      }
+      return None;
     }
     case Kind::EnumElement:
     case Kind::IndirectValue:
@@ -1405,15 +1409,21 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
                  apply);
 
     SILValue superMethod;
-    if (constant.isForeign) {
+    auto *funcDecl = cast<AbstractFunctionDecl>(constant.getDecl());
+
+    auto Opts = SGF.B.getModule().getOptions();
+    if (constant.isForeign ||
+        (Opts.UseNativeSuperMethod && !funcDecl->isFinal())) {
+      // All Objective-C methods and
+      // non-final native Swift methods use dynamic dispatch.
       SILValue Input = super.getValue();
       while (auto *UI = dyn_cast<UpcastInst>(Input))
         Input = UI->getOperand();
       // ObjC super calls require dynamic dispatch.
       setCallee(Callee::forSuperMethod(SGF, Input, constant,
                                        getSubstFnType(), fn));
     } else {
-      // Native Swift super calls are direct.
+      // Native Swift super calls to final methods are direct.
       setCallee(Callee::forDirect(SGF, constant, getSubstFnType(), fn));
     }
 
@@ -3818,12 +3828,13 @@ static Callee getBaseAccessorFunctionRef(SILGenFunction &gen,
     return Callee::forClassMethod(gen, self, constant, substAccessorType,
                                   loc);
 
-  // If this is a "super." dispatch, we either do a direct dispatch in the case
-  // of swift classes or an objc super call.
+  // If this is a "super." dispatch, we do a dynamic dispatch for objc methods
+  // or non-final native Swift methods.
   while (auto *upcast = dyn_cast<UpcastInst>(self))
     self = upcast->getOperand();
 
-  if (constant.isForeign)
+  auto Opts = gen.B.getModule().getOptions();
+  if (constant.isForeign || (Opts.UseNativeSuperMethod && !decl->isFinal()))
     return Callee::forSuperMethod(gen, self, constant, substAccessorType,loc);
 
   return Callee::forDirect(gen, constant, substAccessorType, loc);

test/SILGen/super_class_method.swift

@@ -1,13 +1,27 @@
-// RUN: %target-swift-frontend -emit-silgen -sdk %S/Inputs -I %S/Inputs -enable-source-import %s | FileCheck %s
+// RUN: %target-swift-frontend -emit-silgen -sdk %S/Inputs -I %S/Inputs -enable-source-import %s -use-native-super-method | FileCheck %s
 
-// REQUIRES: objc_interop
+class Parent {
+  class func onlyInParent() {}
+  final class func finalOnlyInParent() {}
+  class func foo() {}
+}
+
+class Child : Parent {}
 
-import Foundation
-class MyFunkyDictionary: NSDictionary {
-  // CHECK-LABEL: sil hidden @_TZFC18super_class_method17MyFunkyDictionary10initialize
-  // CHECK:         super_method [volatile] %0 : $@thick MyFunkyDictionary.Type, #NSObject.initialize!1.foreign : NSObject.Type -> () -> ()
-  override class func initialize() {
-    super.initialize()
+class Grandchild : Child {
+  class func onlyInGrandchild() {
+    // CHECK-LABEL: sil hidden @_TZFC18super_class_method10Grandchild16onlyInGrandchildfT_T_
+    // CHECK-NOT: function_ref @_TZFC18super_class_method6Parent12onlyInParentfT_T_
+    // CHECK: super_method %0 : $@thick Grandchild.Type, #Parent.onlyInParent!1 : Parent.Type -> () -> () , $@convention(thin) (@thick Parent.Type) -> () // user: %5
+    super.onlyInParent()
+    // CHECK: function_ref @_TZFC18super_class_method6Parent17finalOnlyInParentfT_T_
+    super.finalOnlyInParent()
   }
-}
 
+  override class func foo() {
+    // CHECK: sil hidden @_TZFC18super_class_method10Grandchild3foofT_T_ : $@convention(thin) (@thick Grandchild.Type) -> () {
+    // CHECK-NOT: function_ref @_TZFC18super_class_method10Grandchild3foofT_T_
+    // CHECK: super_method %0 : $@thick Grandchild.Type, #Parent.foo!1 : Parent.Type -> () -> () , $@convention(thin) (@thick Parent.Type) -> ()
+    super.foo()
+  }
+}

test/SILGen/super_method.swift

@@ -0,0 +1,25 @@
+// RUN: %target-swift-frontend -emit-sil -sdk %S/Inputs -I %S/Inputs -enable-source-import %s -use-native-super-method | FileCheck %s
+
+class Parent {
+  func onlyInParent() {}
+  final func finalOnlyInParent() {}
+  func foo() {}
+}
+
+class Child : Parent {}
+
+class Grandchild : Child {
+  // CHECK: sil hidden @_TFC12super_method10Grandchild16onlyInGrandchildfT_T_
+  func onlyInGrandchild() {
+    // CHECK: super_method %0 : $Grandchild, #Parent.onlyInParent!1 : Parent -> () -> ()
+    super.onlyInParent()
+    // CHECK: function_ref super_method.Parent.finalOnlyInParent
+    super.finalOnlyInParent()
+  }
+
+  // CHECK: sil hidden @_TFC12super_method10Grandchild3foofT_T_
+  override func foo() {
+    // CHECK: super_method %0 : $Grandchild, #Parent.foo!1 : Parent -> () -> ()
+    super.foo()
+  }
+}

test/SILGen/super_objc_class_method.swift

@@ -0,0 +1,13 @@
+// RUN: %target-swift-frontend -emit-silgen -sdk %S/Inputs -I %S/Inputs -enable-source-import %s -use-native-super-method | FileCheck %s
+
+// REQUIRES: objc_interop
+
+import Foundation
+class MyFunkyDictionary: NSDictionary {
+  // CHECK-LABEL: sil hidden @_TZFC23super_objc_class_method17MyFunkyDictionary10initializefT_T_
+  // CHECK: super_method [volatile] %0 : $@thick MyFunkyDictionary.Type, #NSObject.initialize!1.foreign : NSObject.Type -> () -> ()
+  override class func initialize() {
+    super.initialize()
+  }
+}
+