---

yaml
---
r: 345955
b: refs/heads/master
c: 796add2
h: refs/heads/master
i:
  345953: f414836
  345951: 5c90132

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 3c82c7ea889cbc3c7f53c72baac16a362681286c
+refs/heads/master: 796add2b9fc12e5cf93618a6fec27f53d89c79ee
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/include/swift/SIL/MemAccessUtils.h

@@ -314,6 +314,31 @@ class AccessedStorage {
   bool operator==(const AccessedStorage &) const = delete;
   bool operator!=(const AccessedStorage &) const = delete;
 };
+
+/// Return true if the given storage objects have identical storage locations.
+///
+/// This compares only the AccessedStorage base class bits, ignoring the
+/// subclass bits.
+inline bool accessingIdenticalLocations(AccessedStorage LHS,
+                                        AccessedStorage RHS) {
+  if (LHS.getKind() != RHS.getKind())
+    return false;
+
+  switch (LHS.getKind()) {
+  case swift::AccessedStorage::Box:
+  case swift::AccessedStorage::Stack:
+  case swift::AccessedStorage::Nested:
+  case swift::AccessedStorage::Yield:
+  case swift::AccessedStorage::Unidentified:
+    return LHS.getValue() == RHS.getValue();
+  case swift::AccessedStorage::Argument:
+    return LHS.getParamIndex() == RHS.getParamIndex();
+  case swift::AccessedStorage::Global:
+    return LHS.getGlobal() == RHS.getGlobal();
+  case swift::AccessedStorage::Class:
+    return LHS.getObjectProjection() == RHS.getObjectProjection();
+  }
+}
 } // end namespace swift
 
 namespace llvm {
@@ -355,24 +380,7 @@ template <> struct DenseMapInfo<swift::AccessedStorage> {
   }
 
   static bool isEqual(swift::AccessedStorage LHS, swift::AccessedStorage RHS) {
-    if (LHS.getKind() != RHS.getKind())
-      return false;
-
-    switch (LHS.getKind()) {
-    case swift::AccessedStorage::Box:
-    case swift::AccessedStorage::Stack:
-    case swift::AccessedStorage::Nested:
-    case swift::AccessedStorage::Yield:
-    case swift::AccessedStorage::Unidentified:
-      return LHS.getValue() == RHS.getValue();
-    case swift::AccessedStorage::Argument:
-      return LHS.getParamIndex() == RHS.getParamIndex();
-    case swift::AccessedStorage::Global:
-      return LHS.getGlobal() == RHS.getGlobal();
-    case swift::AccessedStorage::Class:
-        return LHS.getObjectProjection() == RHS.getObjectProjection();
-    }
-    llvm_unreachable("Unhandled AccessedStorageKind");
+    return swift::accessingIdenticalLocations(LHS, RHS);
   }
 };
 

trunk/lib/SIL/MemAccessUtils.cpp

@@ -206,10 +206,10 @@ static bool isUnsafePointerExtraction(StructExtractInst *SEI) {
     || decl == C.getUnsafePointerDecl();
 }
 
-// Given an address base is a block argument, verify that it is actually a box
-// projected from a switch_enum. This is a valid pattern at any SIL stage
-// resulting in a block-type phi. In later SIL stages, the optimizer may form
-// address-type phis, causing this assert if called on those cases.
+// Given a block argument address base, check if it is actually a box projected
+// from a switch_enum. This is a valid pattern at any SIL stage resulting in a
+// block-type phi. In later SIL stages, the optimizer may form address-type
+// phis, causing this assert if called on those cases.
 static void checkSwitchEnumBlockArg(SILPhiArgument *arg) {
   assert(!arg->getType().isAddress());
   SILBasicBlock *Pred = arg->getParent()->getSinglePredecessorBlock();
@@ -289,22 +289,21 @@ AccessedStorage swift::findAccessedStorage(SILValue sourceAddr) {
 
     case ValueKind::SILPhiArgument: {
       auto *phiArg = cast<SILPhiArgument>(address);
-      bool allValsMatch = true;
-      SmallVector<SILValue, 8> incomingPhis;
-      phiArg->getIncomingPhiValues(incomingPhis);
-      if (!incomingPhis.empty()) {
-        auto firstVal = incomingPhis.front();
-        for (auto val : incomingPhis) {
-          if (val != firstVal) {
-            allValsMatch = false;
-            break;
-          }
-        }
-        if (allValsMatch) {
-          return findAccessedStorage(firstVal);
+      if (phiArg->isPhiArgument()) {
+        SmallVector<SILValue, 8> incomingValues;
+        phiArg->getIncomingPhiValues(incomingValues);
+        if (incomingValues.empty())
+          return AccessedStorage();
+
+        auto storage = findAccessedStorage(incomingValues.pop_back_val());
+        for (auto val : incomingValues) {
+          auto otherStorage = findAccessedStorage(val);
+          if (!accessingIdenticalLocations(storage, otherStorage))
+            return AccessedStorage();
         }
+        return storage;
       }
-      // A block argument may be a box value projected out of
+      // A non-phi block argument may be a box value projected out of
       // switch_enum. Address-type block arguments are not allowed.
       if (address->getType().isAddress())
         return AccessedStorage();

trunk/test/SILOptimizer/accessed_storage_analysis.sil

@@ -626,3 +626,38 @@ bb2(%7 : ${ var Int }):
 bb3(%result : $Int):
   return %result : $Int
 }
+
+// Make sure findAccessedStorage returns a valid storage object for an address-phi
+// that feeds ref_element_addr instructions. The ref_element_addr's need to have the
+// same base object and same field id.
+// <rdar://problem/46114512> SIL verification failed: Unknown formal access pattern: storage
+class BaseClass {
+  var f: Float = 0.0
+}
+
+class SubClass : BaseClass {}
+
+// CHECK-LABEL: @testElementAddressPhiAccess
+// CHECK: [read] [no_nested_conflict] Class %{{.*}} = upcast %0 : $SubClass to $BaseClass
+// CHECK: Field: @_hasInitialValue var f: Float
+sil @testElementAddressPhiAccess : $@convention(thin) (@guaranteed SubClass) -> () {
+bb0(%0 : $SubClass):
+  %base = upcast %0 : $SubClass to $BaseClass
+  cond_br undef, bb1, bb2
+
+bb1:
+  %ref1 = ref_element_addr %base : $BaseClass, #BaseClass.f
+  br bb3(%ref1 : $*Float)
+
+bb2:
+  %ref2 = ref_element_addr %base : $BaseClass, #BaseClass.f
+  br bb3(%ref2 : $*Float)
+
+bb3(%phi : $*Float):
+  %access = begin_access [read] [dynamic] [no_nested_conflict] %phi : $*Float
+  %addr = struct_element_addr %access : $*Float, #Float._value
+  %val = load %addr : $*Builtin.FPIEEE32
+  end_access %access : $*Float
+  %v = tuple ()
+  return %v : $()
+}