---

yaml
---
r: 349535
b: refs/heads/master-next
c: 0fd3e1d
h: refs/heads/master
i:
  349533: 66ac745
  349531: ee685b6
  349527: 417081d
  349519: da8a0a5
  349503: 50ed6e1

Author: swift-ci

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 3574c513bbc5578dd9346b4ea9ab5995c5927bb5
-refs/heads/master-next: bb83c392ffb3cce181857195d4533f61bfd534c5
+refs/heads/master-next: 0fd3e1dfb7f3f131d5d578f6b1e2322c7d4fd768
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-b: 66d897bfcf64a82cb9a87f5e663d889189d06d07

branches/master-next/include/swift/Reflection/ReflectionContext.h

@@ -193,6 +193,11 @@ class ReflectionContext
       }
       RangeStart = std::min(RangeStart, (uint64_t)S->addr + Slide);
       RangeEnd = std::max(RangeEnd, (uint64_t)(S->addr + S->size + Slide));
+      // Keep the range rounded to 8 byte alignment on both ends so we don't
+      // introduce misaligned pointers mapping between local and remote
+      // address space.
+      RangeStart = RangeStart & ~7;
+      RangeEnd = RangeEnd + 7 & ~7;      
     }
 
     if (RangeStart == UINT64_MAX && RangeEnd == UINT64_MAX)

branches/master-next/include/swift/SIL/MemAccessUtils.h

@@ -8,8 +8,29 @@
 // See https://swift.org/LICENSE.txt for license information
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
-// These utilities live in SIL/ so they be used by SIL verification.
-//
+//===----------------------------------------------------------------------===//
+///
+/// These utilities model formal memory access locations as marked by
+/// begin_access and end_access instructions. The formal memory locations
+/// identified here must be consistent with language rules for exclusity
+/// enforcement. This is not meant to be a utility to reason about other general
+/// properties of SIL memory operations such as reference count identity,
+/// ownership, or aliasing. Code that queries the properties of arbitrary memory
+/// operations independent of begin_access instructions should use a different
+/// interface.
+///
+/// SIL memory addresses used for formal access need to meet special
+/// requirements. In particular, it must be possible to identifiy the storage by
+/// following the pointer's provenance. This is *not* true for SIL memory
+/// operations in general. The utilities cannot simply bailout on unrecognized
+/// patterns. Doing so would lead to undefined program behavior, which isn't
+/// something that can be directly tested (i.e. if this breaks, we won't see
+/// test failures).
+///
+/// These utilities are mainly meant to be used by AccessEnforcement passes,
+/// which optimize exclusivity enforcement. They live in SIL so they can be used
+/// by SIL verification.
+///
 //===----------------------------------------------------------------------===//
 
 #ifndef SWIFT_SIL_MEMACCESSUTILS_H
@@ -31,6 +52,23 @@ inline bool accessKindMayConflict(SILAccessKind a, SILAccessKind b) {
 
 /// Represents the identity of a storage object being accessed.
 ///
+/// AccessedStorage is carefully designed to solve three problems:
+///
+/// 1. Full specification and verification of SIL's model for exclusive
+///    formal memory access, as enforced by "access markers". It is not a
+///    model to encompass all SIL memory operations.
+///
+/// 2. A bitwise comparable encoding and hash key to identify each location
+///    being formally accessed. Any two accesses of uniquely identified storage
+///    must have the same key if they access the same storage and distinct keys
+///    if they access distinct storage. Accesses to non-uniquely identified
+///    storage should ideally have the same key if they may point to the same
+///    storage.
+///
+/// 3. Complete identification of all class or global accesses. Failing to
+///    identify a class or global access will introduce undefined program
+///    behavior which can't be tested.
+///
 /// AccessedStorage may be one of several kinds of "identified" storage
 /// objects, or may be valid, but Unidentified storage. An identified object
 /// is known to identify the base of the accessed storage, whether that is a
@@ -220,7 +258,8 @@ class AccessedStorage {
   /// Return true if the given storage objects have identical storage locations.
   ///
   /// This compares only the AccessedStorage base class bits, ignoring the
-  /// subclass bits. It is used for hash lookup equality.
+  /// subclass bits. It is used for hash lookup equality, so it should not
+  /// perform any additional lookups or dereference memory outside itself.
   bool hasIdenticalBase(const AccessedStorage &other) const {
     if (getKind() != other.getKind())
       return false;

branches/master-next/lib/SIL/MemAccessUtils.cpp

@@ -598,7 +598,7 @@ static void visitBuiltinAddress(BuiltinInst *builtin,
     switch (kind.getValue()) {
     default:
       builtin->dump();
-      llvm_unreachable("unexpected bulitin memory access.");
+      llvm_unreachable("unexpected builtin memory access.");
 
       // WillThrow exists for the debugger, does nothing.
     case BuiltinValueKind::WillThrow:

branches/master-next/validation-test/Reflection/functions.swift

@@ -7,9 +7,6 @@
 // FIXME: Should not require objc_interop -- please put Objective-C-specific
 // testcases in functions_objc.swift
 
-// rdar://54556791
-// UNSUPPORTED: CPU=armv7k
-
 // REQUIRES: objc_interop
 // REQUIRES: executable_test