Merge pull request swiftlang#1159 from aschwaighofer/my-swift-2.2-branch

[Swift 2.2] Perform a dynamic method call if a class has objc ancestry in specula…

Author: tkremenek

lib/SILOptimizer/Transforms/SpeculativeDevirtualizer.cpp

@@ -216,6 +216,12 @@ static bool isDefaultCaseKnown(ClassHierarchyAnalysis *CHA,
   if (CD->isFinal())
     return true;
 
+  // If the class has an @objc ancestry it can be dynamically subclassed and we
+  // can't therefore statically know the default case.
+  auto Ancestry = CD->checkObjCAncestry();
+  if (Ancestry != ObjCClassKind::NonObjC)
+    return false;
+
   // Without an associated context we cannot perform any
   // access-based optimizations.
   if (!DC)

test/SILOptimizer/devirt_speculative.sil

@@ -0,0 +1,106 @@
+// RUN: %target-sil-opt -enable-sil-verify-all %s -specdevirt  | FileCheck %s
+
+sil_stage canonical
+
+@objc class MyNSObject {}
+private class Base : MyNSObject {
+   override init()
+  @inline(never) func foo()
+}
+
+private class Sub : Base {
+  override init()
+  @inline(never) override func foo()
+}
+
+sil private [noinline] @_TBaseFooFun : $@convention(method) (@guaranteed Base) -> () {
+bb0(%0 : $Base):
+  %1 = tuple()
+  return %1 : $()
+}
+
+sil private [noinline] @_TSubFooFun : $@convention(method) (@guaranteed Sub) -> () {
+bb0(%0 : $Sub):
+  %1 = tuple()
+  return %1 : $()
+}
+
+sil_vtable Base {
+  #Base.foo!1: _TBaseFooFun
+}
+
+sil_vtable Sub {
+  #Base.foo!1: _TSubFooFun
+}
+
+sil @test_objc_ancestry : $@convention(thin) (@guaranteed Base) -> () {
+bb0(%0: $Base):
+  %1 = class_method %0 : $Base, #Base.foo!1 : (Base) -> () -> () , $@convention(method) (@guaranteed Base) -> ()
+  %2 = apply %1(%0) : $@convention(method) (@guaranteed Base) -> ()
+  %3 = tuple()
+  return %3 : $()
+}
+
+// Make sure we leave the generic method call because an objc derived class can be extended at runtime.
+
+// CHECK-LABEL: sil @test_objc_ancestry
+// CHECK: bb0
+// CHECK:  [[METH:%.*]] = class_method %0 : $Base, #Base.foo!1 : (Base) -> () -> () , $@convention(method) (@guaranteed Base) -> ()
+// CHECK:  checked_cast_br [exact] %0 : $Base to $Base, bb{{.*}}, bb[[CHECK2:[0-9]+]]
+// CHECK: bb[[CHECK2]]{{.*}}:
+// CHECK:  checked_cast_br [exact] %0 : $Base to $Sub, bb{{.*}}, bb[[GENCALL:[0-9]+]]
+// CHECK: bb[[GENCALL]]{{.*}}:
+// CHECK:  apply [[METH]]
+
+struct MyValue {}
+
+private class Generic<T> : MyNSObject {
+  override init()
+}
+
+private class Base2 : Generic<MyValue> {
+   override init()
+  @inline(never) func foo()
+}
+
+private class Sub2 : Base2 {
+  override init()
+  @inline(never) override func foo()
+}
+
+sil private [noinline] @_TBase2FooFun : $@convention(method) (@guaranteed Base2) -> () {
+bb0(%0 : $Base2):
+  %1 = tuple()
+  return %1 : $()
+}
+
+sil private [noinline] @_TSub2FooFun : $@convention(method) (@guaranteed Sub2) -> () {
+bb0(%0 : $Sub2):
+  %1 = tuple()
+  return %1 : $()
+}
+
+sil_vtable Base2 {
+  #Base2.foo!1: _TBase2FooFun
+}
+
+sil_vtable Sub2 {
+  #Base2.foo!1: _TSub2FooFun
+}
+
+sil @test_objc_ancestry2 : $@convention(thin) (@guaranteed Base2) -> () {
+bb0(%0: $Base2):
+  %1 = class_method %0 : $Base2, #Base2.foo!1 : (Base2) -> () -> () , $@convention(method) (@guaranteed Base2) -> ()
+  %2 = apply %1(%0) : $@convention(method) (@guaranteed Base2) -> ()
+  %3 = tuple()
+  return %3 : $()
+}
+
+// CHECK-LABEL: sil @test_objc_ancestry2
+// CHECK: bb0
+// CHECK:  [[METH:%.*]] = class_method %0 : $Base2, #Base2.foo!1 : (Base2) -> () -> () , $@convention(method) (@guaranteed Base2) -> ()
+// CHECK:  checked_cast_br [exact] %0 : $Base2 to $Base2, bb{{.*}}, bb[[CHECK2:[0-9]+]]
+// CHECK: bb[[CHECK2]]{{.*}}:
+// CHECK:  checked_cast_br [exact] %0 : $Base2 to $Sub2, bb{{.*}}, bb[[GENCALL:[0-9]+]]
+// CHECK: bb[[GENCALL]]{{.*}}:
+// CHECK:  apply [[METH]]