Manually check if types are the same when checking for change and update

tests

Author: zoecarver

lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp

@@ -872,10 +872,6 @@ SILInstruction *SILCombiner::createApplyWithConcreteType(
       NewArgs.push_back(Apply.getArgument(ArgIdx));
   }
 
-  // Keep track of weather we made any updates at all. Otherwise, we will
-  // have an infinite loop.
-  bool madeUpdate = false;
-
   // Transform the parameter arguments.
   SmallVector<ConcreteArgumentCopy, 4> concreteArgCopies;
   for (unsigned EndIdx = Apply.getNumArguments(); ArgIdx < EndIdx; ++ArgIdx) {
@@ -903,7 +899,6 @@ SILInstruction *SILCombiner::createApplyWithConcreteType(
     if (argSub) {
       concreteArgCopies.push_back(*argSub);
       NewArgs.push_back(argSub->tempArg);
-      madeUpdate = true;
     } else {
       NewArgs.push_back(CEI.ConcreteValue);
     }
@@ -929,7 +924,8 @@ SILInstruction *SILCombiner::createApplyWithConcreteType(
         });
   }
 
-  bool canUpdateArgs = [&]() {
+  bool canUpdateArgs, madeUpdate;
+  std::tie(canUpdateArgs, madeUpdate) = [&]() {
     auto substTy =
         Apply.getCallee()
             ->getType()
@@ -939,12 +935,16 @@ SILInstruction *SILCombiner::createApplyWithConcreteType(
     SILFunctionConventions conv(substTy,
                                 SILModuleConventions(Apply.getModule()));
     bool canUpdate = true;
+    // Keep track of weather we made any updates at all. Otherwise, we will
+    // have an infinite loop.
+    bool madeUpdate = false;
     for (unsigned index = 0; index < conv.getNumSILArguments(); ++index) {
       canUpdate &= conv.getSILArgumentType(index) == NewArgs[index]->getType();
+      madeUpdate |= NewArgs[index]->getType() != Apply.getArgument(index)->getType();
     }
-    return canUpdate;
+    return std::make_tuple(canUpdate, madeUpdate);
   }();
-
+  
   if (!canUpdateArgs || !madeUpdate) {
     // Remove any new instructions created while attempting to optimize this
     // apply. Since the apply was never rewritten, if they aren't removed here,

test/SILOptimizer/devirtualize_protocol_composition_two_stores.sil

@@ -12,51 +12,51 @@ public class A {
 }
 
 public protocol P {
-  func foo() -> Int
+  func foo() -> Int64
 }
 
 public class B : A, P {
-  public func foo() -> Int
+  public func foo() -> Int64
   @objc deinit
   override init()
 }
 
 public class C : A, P {
-  public func foo() -> Int
+  public func foo() -> Int64
   @objc deinit
   override init()
 }
 
-func imp(x: A & P, y: A & P) -> Int
+func imp(x: A & P, y: A & P) -> Int64
 
-public func test(x: B, y: C) -> Int
+public func test(x: B, y: C) -> Int64
 
 // protocol witness for P.foo() in conformance B
-sil shared [transparent] [serialized] [thunk] @Pfoo : $@convention(witness_method: P) (@in_guaranteed B) -> Int {
+sil shared [transparent] [serialized] [thunk] @Pfoo : $@convention(witness_method: P) (@in_guaranteed B) -> Int64 {
 // %0                                             // user: %1
 bb0(%0 : $*B):
   %1 = load %0 : $*B                              // users: %2, %3
-  %2 = class_method %1 : $B, #B.foo!1 : (B) -> () -> Int, $@convention(method) (@guaranteed B) -> Int // user: %3
-  %3 = apply %2(%1) : $@convention(method) (@guaranteed B) -> Int // user: %4
-  return %3 : $Int                                // id: %4
+  %2 = class_method %1 : $B, #B.foo!1 : (B) -> () -> Int64, $@convention(method) (@guaranteed B) -> Int64 // user: %3
+  %3 = apply %2(%1) : $@convention(method) (@guaranteed B) -> Int64 // user: %4
+  return %3 : $Int64                                // id: %4
 } // end sil function 'Pfoo'
 
 // B.foo()
-sil [noinline] @foo : $@convention(method) (@guaranteed B) -> Int {
+sil [noinline] @foo : $@convention(method) (@guaranteed B) -> Int64 {
 // %0                                             // user: %1
 bb0(%0 : $B):
   debug_value %0 : $B, let, name "self", argno 1  // id: %1
   %2 = integer_literal $Builtin.Int64, 1          // user: %3
-  %3 = struct $Int (%2 : $Builtin.Int64)          // user: %4
-  return %3 : $Int                                // id: %4
+  %3 = struct $Int64 (%2 : $Builtin.Int64)          // user: %4
+  return %3 : $Int64                                // id: %4
 } // end sil function 'foo'
 
 
 // This function calls @impl. The optimizer generates a specialization of impl
 // based on the arguments passed to it here. Even though this function isn't
 // directly checked, it is essentail for the optimization.
 // test(x:y:)
-sil @test :$@convention(thin) (@guaranteed B, @guaranteed C) -> Int {
+sil @test :$@convention(thin) (@guaranteed B, @guaranteed C) -> Int64 {
 // %0                                             // users: %5, %4, %2
 // %1                                             // users: %7, %6, %3
 bb0(%0 : $B, %1 : $C):
@@ -67,11 +67,11 @@ bb0(%0 : $B, %1 : $C):
   strong_retain %1 : $C                           // id: %6
   %7 = init_existential_ref %1 : $C : $C, $A & P  // users: %10, %9
   // function_ref imp(x:y:)
-  %8 = function_ref @impl : $@convention(thin) (@guaranteed A & P, @guaranteed A & P) -> Int // user: %9
-  %9 = apply %8(%5, %7) : $@convention(thin) (@guaranteed A & P, @guaranteed A & P) -> Int // user: %12
+  %8 = function_ref @impl : $@convention(thin) (@guaranteed A & P, @guaranteed A & P) -> Int64 // user: %9
+  %9 = apply %8(%5, %7) : $@convention(thin) (@guaranteed A & P, @guaranteed A & P) -> Int64 // user: %12
   strong_release %7 : $A & P                      // id: %10
   strong_release %5 : $A & P                      // id: %11
-  return %9 : $Int                                // id: %12
+  return %9 : $Int64                                // id: %12
 } // end sil function 'test'
 
 // We're looking of an optimized spcialization of @impl, not @impl itself.
@@ -83,7 +83,7 @@ bb0(%0 : $B, %1 : $C):
 // This function will be passed arguments of type B and C for arguments
 // %0 and %1 respectively. We want to make sure that we call B's foo method
 // and not C's foo method.
-sil hidden [noinline] @impl : $@convention(thin) (@guaranteed A & P, @guaranteed A & P) -> Int {
+sil hidden [noinline] @impl : $@convention(thin) (@guaranteed A & P, @guaranteed A & P) -> Int64 {
 bb0(%0 : $A & P, %1 : $A & P):
   %2 = open_existential_ref %0 : $A & P to $@opened("A1F1B526-1463-11EA-932F-ACBC329C418B") A & P
   %3 = unchecked_ref_cast %1 : $A & P to $@opened("A1F1B526-1463-11EA-932F-ACBC329C418B") A & P
@@ -94,28 +94,28 @@ bb0(%0 : $A & P, %1 : $A & P):
   // We want to make sure that we picked up on the FIRST store and not the second one.
   // class C's foo method is named "bar" whereas class B's foo method is named "foo".
   // We want to make sure that we call a function named "foo" not "bar".
-  // CHECK: [[FN:%[0-9]+]] = function_ref @${{.*}}foo{{.*}} : $@convention(thin) () -> Int
-  %7 = witness_method $@opened("A1F1B526-1463-11EA-932F-ACBC329C418B") A & P, #P.foo!1 : <Self where Self : P> (Self) -> () -> Int, %2 : $@opened("A1F1B526-1463-11EA-932F-ACBC329C418B") A & P : $@convention(witness_method: P) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> Int
+  // CHECK: [[FN:%[0-9]+]] = function_ref @${{.*}}foo{{.*}} : $@convention(thin) () -> Int64
+  %7 = witness_method $@opened("A1F1B526-1463-11EA-932F-ACBC329C418B") A & P, #P.foo!1 : <Self where Self : P> (Self) -> () -> Int64, %2 : $@opened("A1F1B526-1463-11EA-932F-ACBC329C418B") A & P : $@convention(witness_method: P) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> Int64
   // CHECK: apply [[FN]]
-  %8 = apply %7<@opened("A1F1B526-1463-11EA-932F-ACBC329C418B") A & P>(%5) : $@convention(witness_method: P) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> Int
+  %8 = apply %7<@opened("A1F1B526-1463-11EA-932F-ACBC329C418B") A & P>(%5) : $@convention(witness_method: P) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> Int64
 
   store %3 to %5 : $*@opened("A1F1B526-1463-11EA-932F-ACBC329C418B") A & P
   dealloc_stack %5 : $*@opened("A1F1B526-1463-11EA-932F-ACBC329C418B") A & P
-  return %8 : $Int
+  return %8 : $Int64
 // CHECK-LABEL: end sil function {{.*}}impl{{.*}}
 } // end sil function 'impl'
 
 // C.foo()
-sil @bar : $@convention(method) (@guaranteed C) -> Int
+sil @bar : $@convention(method) (@guaranteed C) -> Int64
 
 sil_vtable [serialized] B {
-  #B.foo!1: (B) -> () -> Int : @foo  // B.foo()
+  #B.foo!1: (B) -> () -> Int64 : @foo  // B.foo()
 }
 
 sil_vtable [serialized] C {
-  #C.foo!1: (C) -> () -> Int : @bar
+  #C.foo!1: (C) -> () -> Int64 : @bar
 }
 
 sil_witness_table [serialized] B: P module run {
-  method #P.foo!1: <Self where Self : P> (Self) -> () -> Int : @Pfoo  // protocol witness for P.foo() in conformance B
+  method #P.foo!1: <Self where Self : P> (Self) -> () -> Int64 : @Pfoo  // protocol witness for P.foo() in conformance B
 }