Merge pull request swiftlang#1485 from tkremenek/swift-2.2-PR-LetPropertiesOptPass-Miscompile

Fix a bug in LetPropertiesOptPass

Author: tkremenek

lib/SILOptimizer/IPO/LetPropertiesOpts.cpp

@@ -246,8 +246,9 @@ static bool compareInsnSequences(SmallVectorImpl<SILInstruction *> &LHS,
 /// initializing a given property.
 SILValue findStoredValue(SILFunction *Init, VarDecl *Property,
                          SmallVectorImpl<SILInstruction *> &Insns) {
-  for (auto &BB: *Init) {
-    for (auto &I: BB) {
+  SILValue ResultValue;
+  for (auto &BB : *Init) {
+    for (auto &I : BB) {
       if (auto *RI = dyn_cast<ReturnInst>(&I)) {
         if (auto *SI = dyn_cast<StructInst>(RI->getOperand())) {
           auto Value = SI->getFieldValue(Property);
@@ -268,22 +269,24 @@ SILValue findStoredValue(SILFunction *Init, VarDecl *Property,
         auto REAI = dyn_cast<RefElementAddrInst>(Dest);
         if (!REAI || REAI->getField() != Property)
             continue;
-
+        // Bail, if it is not the only assignment to the
+        // required property.
+        if (ResultValue)
+          return SILValue();
         auto Value = SI->getSrc();
         SmallVector<SILInstruction *, 8> ReverseInsns;
-        // ReverseInsns.push_back(SI);
         if (!analyzeStaticInitializer(Value, ReverseInsns))
           return SILValue();
         // Produce a correct order of instructions.
         while (!ReverseInsns.empty()) {
           Insns.push_back(ReverseInsns.pop_back_val());
         }
-        return Value;
+        ResultValue = Value;
       }
     }
   }
 
-  return SILValue();
+  return ResultValue;
 }
 
 /// Try to find a sequence of instructions which initializes

test/SILOptimizer/let_properties_opts.swift

@@ -86,6 +86,18 @@ public struct Boo {
   public init(i:Int64) {}
 }
 
+public class Foo2 {
+  internal let x: Int32
+  @inline(never)
+  init(count: Int32) {
+    if count < 2 {
+      x = 5
+    } else {
+      x = 10
+    }
+  }
+}
+
 // Check that Foo1.Prop1 is not constant-folded, because its value is unknown, since it is initialized differently
 // by Foo1 initializers.
 
@@ -170,3 +182,15 @@ public func testStructLet(inout b: Boo) -> Int32 {
 public func testStructPublicLet(b: Boo) -> Int32 {
   return b.Prop0
 }
+
+// Check that f.x is not constant folded, because the initializer of Foo2 has multiple
+// assignments to the property x with different values.
+// CHECK-LABEL: sil @_TF19let_properties_opts13testClassLet2FCS_4Foo2Vs5Int32 : $@convention(thin) (@owned Foo2) -> Int32
+// bb0
+// CHECK: ref_element_addr %{{[0-9]+}} : $Foo2, #Foo2.x
+// CHECK-NOT: ref_element_addr %{{[0-9]+}} : $Foo2, #Foo2.x
+// CHECK-NOT: ref_element_addr %{{[0-9]+}} : $Foo2, #Foo2.x
+// CHECK: return
+public func testClassLet2(f: Foo2) -> Int32 {
+  return f.x + f.x
+}