---

yaml
---
r: 347128
b: refs/heads/master
c: ed8c68d
h: refs/heads/master

Author: bob-wilson

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 64d0e6bbc558c53e7bb50de9c9d7897d35c444eb
+refs/heads/master: ed8c68d4243b59861bbc9776ee5a6ad77a5cc354
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/CMakeLists.txt

@@ -235,8 +235,8 @@ option(SWIFT_RUNTIME_CRASH_REPORTER_CLIENT
     FALSE)
 
 option(SWIFT_DARWIN_ENABLE_STABLE_ABI_BIT
-    "Enable the Swift stable ABI's class marker bit"
-    FALSE)
+    "Enable the Swift stable ABI's class marker bit for new deployment targets"
+    TRUE)
 
 set(SWIFT_DARWIN_XCRUN_TOOLCHAIN "XcodeDefault" CACHE STRING
     "The name of the toolchain to pass to 'xcrun'")

trunk/include/swift/ABI/Metadata.h

@@ -1192,6 +1192,31 @@ struct TargetClassMetadata : public TargetAnyClassMetadata<Runtime> {
     return bounds;
   }
 
+  /// Given a statically-emitted metadata template, this sets the correct
+  /// "is Swift" bit for the current runtime. Depending on the deployment
+  /// target a binary was compiled for, statically emitted metadata templates
+  /// may have a different bit set from the one that this runtime canonically
+  /// considers the "is Swift" bit.
+  void setAsTypeMetadata() {
+    // If the wrong "is Swift" bit is set, set the correct one.
+    //
+    // Note that the only time we should see the "new" bit set while
+    // expecting the "old" one is when running a binary built for a
+    // new OS on an old OS, which is not supported, however we do
+    // have tests that exercise this scenario.
+    auto otherSwiftBit = (3ULL - SWIFT_CLASS_IS_SWIFT_MASK);
+    assert(otherSwiftBit == 1ULL || otherSwiftBit == 2ULL);
+
+    if ((this->Data & 3) == otherSwiftBit) {
+      this->Data ^= 3;
+    }
+
+    // Otherwise there should be nothing to do, since only the old "is
+    // Swift" bit is used for backward-deployed runtimes.
+    
+    assert(isTypeMetadata());
+  }
+
   static bool classof(const TargetMetadata<Runtime> *metadata) {
     return metadata->getKind() == MetadataKind::Class;
   }

trunk/include/swift/Runtime/BackDeployment.h

@@ -0,0 +1,45 @@
+//===--- BackDeployment.h - Support for running on older OS versions. -----===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_STDLIB_BACKDEPLOYMENT_H
+#define SWIFT_STDLIB_BACKDEPLOYMENT_H
+
+#if defined(__APPLE__) && defined(__MACH__)
+
+#include "swift/Runtime/Config.h"
+#include "../../../stdlib/public/SwiftShims/Visibility.h"
+
+#ifdef __cplusplus
+namespace swift { extern "C" {
+#endif
+
+#if SWIFT_CLASS_IS_SWIFT_MASK_GLOBAL_VARIABLE
+# ifndef __cplusplus
+// This file gets included from some C/ObjC files and
+// SWIFT_RUNTIME_STDLIB_SPI doesn't imply extern in C.
+extern
+# endif
+SWIFT_RUNTIME_STDLIB_SPI unsigned long long _swift_classIsSwiftMask;
+#endif
+
+/// Returns true if the current OS version, at runtime, is a back-deployment
+/// version.
+SWIFT_RUNTIME_STDLIB_INTERNAL
+int _swift_isBackDeploying();
+
+#ifdef __cplusplus
+}} // extern "C", namespace swift
+#endif
+
+#endif // defined(__APPLE__) && defined(__MACH__)
+
+#endif // SWIFT_STDLIB_BACKDEPLOYMENT_H

trunk/include/swift/Runtime/CMakeConfig.h.in

@@ -5,5 +5,7 @@
 #define SWIFT_RUNTIME_CMAKECONFIG_H
 
 #cmakedefine01 SWIFT_DARWIN_ENABLE_STABLE_ABI_BIT
+#cmakedefine01 SWIFT_BNI_OS_BUILD
+#cmakedefine01 SWIFT_BNI_XCODE_BUILD
 
 #endif

trunk/include/swift/Runtime/CMakeLists.txt

@@ -1,2 +1,13 @@
+# Detect B&I builds.
+set(SWIFT_BNI_OS_BUILD FALSE)
+set(SWIFT_BNI_XCODE_BUILD FALSE)
+if(DEFINED ENV{RC_XBS})
+  if(NOT DEFINED ENV{RC_XCODE} OR NOT "$ENV{RC_XCODE}")
+    set(SWIFT_BNI_OS_BUILD TRUE)
+  else()
+    set(SWIFT_BNI_XCODE_BUILD TRUE)
+  endif()
+endif()
+
 configure_file(CMakeConfig.h.in ${CMAKE_CURRENT_BINARY_DIR}/CMakeConfig.h
                ESCAPE_QUOTES @ONLY)

trunk/include/swift/Runtime/Config.h

@@ -141,10 +141,27 @@
 /// Which bits in the class metadata are used to distinguish Swift classes
 /// from ObjC classes?
 #ifndef SWIFT_CLASS_IS_SWIFT_MASK
-# if defined(__APPLE__) && SWIFT_OBJC_INTEROP && SWIFT_DARWIN_ENABLE_STABLE_ABI_BIT
+
+// Non-Apple platforms always use 1.
+# if !defined(__APPLE__)
+#  define SWIFT_CLASS_IS_SWIFT_MASK 1ULL
+
+// Builds for Swift-in-the-OS always use 2.
+# elif SWIFT_BNI_OS_BUILD
 #  define SWIFT_CLASS_IS_SWIFT_MASK 2ULL
-# else
+
+// Builds for Xcode always use 1.
+# elif SWIFT_BNI_XCODE_BUILD
 #  define SWIFT_CLASS_IS_SWIFT_MASK 1ULL
+
+// Other builds (such as local builds on developers' computers)
+// dynamically choose the bit at runtime based on the current OS
+// version.
+# else
+#  define SWIFT_CLASS_IS_SWIFT_MASK _swift_classIsSwiftMask
+#  define SWIFT_CLASS_IS_SWIFT_MASK_GLOBAL_VARIABLE 1
+#  include "BackDeployment.h"
+
 # endif
 #endif
 

trunk/include/swift/SwiftRemoteMirror/SwiftRemoteMirror.h

@@ -37,6 +37,8 @@
 extern "C" {
 #endif
 
+extern unsigned long long swift_reflection_classIsSwiftMask;
+
 /// Get the metadata version supported by the Remote Mirror library.
 SWIFT_REMOTE_MIRROR_LINKAGE
 uint16_t swift_reflection_getSupportedMetadataVersion(void);

trunk/lib/Frontend/CompilerInvocation.cpp

@@ -429,7 +429,11 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
   Opts.EnableSILOpaqueValues |= Args.hasArg(OPT_enable_sil_opaque_values);
 
 #if SWIFT_DARWIN_ENABLE_STABLE_ABI_BIT
-  Opts.UseDarwinPreStableABIBit = false;
+  Opts.UseDarwinPreStableABIBit =
+    (Target.isMacOSX() && Target.isMacOSXVersionLT(10, 14, 4)) ||
+    (Target.isiOS() && Target.isOSVersionLT(12, 2)) ||
+    (Target.isTvOS() && Target.isOSVersionLT(12, 2)) ||
+    (Target.isWatchOS() && Target.isOSVersionLT(5, 2));
 #else
   Opts.UseDarwinPreStableABIBit = true;
 #endif

trunk/lib/SILGen/SILGenPattern.cpp

@@ -2325,16 +2325,18 @@ void PatternMatchEmission::initSharedCaseBlockDest(CaseStmt *caseBlock,
   }
 
   auto pattern = caseBlock->getCaseLabelItems()[0].getPattern();
-  pattern->forEachVariable([&](VarDecl *V) {
-    if (!V->hasName())
-      return;
+  SmallVector<VarDecl *, 4> patternVarDecls;
+  pattern->collectVariables(patternVarDecls);
+  for (auto *vd : patternVarDecls) {
+    if (!vd->hasName())
+      continue;
 
     // We don't pass address-only values in basic block arguments.
-    SILType ty = SGF.getLoweredType(V->getType());
+    SILType ty = SGF.getLoweredType(vd->getType());
     if (ty.isAddressOnly(SGF.F.getModule()))
-      return;
-    block->createPhiArgument(ty, ValueOwnershipKind::Owned, V);
-  });
+      continue;
+    block->createPhiArgument(ty, ValueOwnershipKind::Owned, vd);
+  }
 }
 
 /// Retrieve the jump destination for a shared case block.
@@ -2362,9 +2364,11 @@ void PatternMatchEmission::emitAddressOnlyAllocations() {
     // to point to the incoming args and setup initialization so any args needing
     // cleanup will get that as well.
     auto pattern = caseBlock->getCaseLabelItems()[0].getPattern();
-    pattern->forEachVariable([&](VarDecl *vd) {
+    SmallVector<VarDecl *, 4> patternVarDecls;
+    pattern->collectVariables(patternVarDecls);
+    for (auto *vd : patternVarDecls) {
       if (!vd->hasName())
-        return;
+        continue;
 
       SILType ty = SGF.getLoweredType(vd->getType());
       if (ty.isNull()) {
@@ -2383,12 +2387,11 @@ void PatternMatchEmission::emitAddressOnlyAllocations() {
         }
       }
 
-      if (ty.isAddressOnly(SGF.F.getModule())) {
-        assert(!Temporaries[vd]);
-        Temporaries[vd] = SGF.emitTemporaryAllocation(vd, ty);
-        return;
-      }
-    });
+      if (!ty.isAddressOnly(SGF.F.getModule()))
+        continue;
+      assert(!Temporaries[vd]);
+      Temporaries[vd] = SGF.emitTemporaryAllocation(vd, ty);
+    }
   }
 
   // Now we have all of our cleanups entered, so we can record the
@@ -2458,12 +2461,14 @@ void PatternMatchEmission::emitSharedCaseBlocks() {
     // needing cleanup will get that as well.
     Scope scope(SGF.Cleanups, CleanupLocation(caseBlock));
     auto pattern = caseBlock->getCaseLabelItems()[0].getPattern();
+    SmallVector<VarDecl *, 4> patternVarDecls;
+    pattern->collectVariables(patternVarDecls);
     unsigned argIndex = 0;
-    pattern->forEachVariable([&](VarDecl *V) {
-      if (!V->hasName())
-        return;
+    for (auto *vd : patternVarDecls) {
+      if (!vd->hasName())
+        continue;
 
-      SILType ty = SGF.getLoweredType(V->getType());
+      SILType ty = SGF.getLoweredType(vd->getType());
 
       // Initialize mv at +1. We always pass values in at +1 for today into
       // shared blocks.
@@ -2478,7 +2483,7 @@ void PatternMatchEmission::emitSharedCaseBlocks() {
         //
         // There's nothing to do here, since the value should already have
         // been initialized on entry.
-        auto found = Temporaries.find(V);
+        auto found = Temporaries.find(vd);
         assert(found != Temporaries.end());
         mv = SGF.emitManagedRValueWithCleanup(found->second);
       } else {
@@ -2488,20 +2493,20 @@ void PatternMatchEmission::emitSharedCaseBlocks() {
         mv = SGF.emitManagedRValueWithCleanup(arg);
       }
 
-      if (V->isLet()) {
+      if (vd->isLet()) {
         // Just emit a let and leave the cleanup alone.
-        SGF.VarLocs[V].value = mv.getValue();
-        return;
+        SGF.VarLocs[vd].value = mv.getValue();
+        continue;
       }
 
       // Otherwise, the pattern variables were all emitted as lets and one got
       // passed in. Since we have a var, alloc a box for the var and forward in
       // the chosen value.
-      SGF.VarLocs.erase(V);
-      auto newVar = SGF.emitInitializationForVarDecl(V, V->isLet());
-      newVar->copyOrInitValueInto(SGF, V, mv, /*isInit*/ true);
+      SGF.VarLocs.erase(vd);
+      auto newVar = SGF.emitInitializationForVarDecl(vd, vd->isLet());
+      newVar->copyOrInitValueInto(SGF, vd, mv, /*isInit*/ true);
       newVar->finishInitialization(SGF);
-    });
+    }
 
     // Now that we have setup all of the VarLocs correctly, emit the shared case
     // body.

trunk/stdlib/public/SwiftRemoteMirror/SwiftRemoteMirror.cpp

@@ -10,6 +10,9 @@
 //
 //===----------------------------------------------------------------------===//
 
+#define SWIFT_CLASS_IS_SWIFT_MASK swift_reflection_classIsSwiftMask
+extern "C" unsigned long long swift_reflection_classIsSwiftMask = 2;
+
 #include "swift/Reflection/ReflectionContext.h"
 #include "swift/Reflection/TypeLowering.h"
 #include "swift/Remote/CMemoryReader.h"

trunk/stdlib/public/runtime/BackDeployment.cpp

@@ -0,0 +1,64 @@
+//===--- BackDeployment.cpp - Support for running on older OS versions. ---===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/Runtime/BackDeployment.h"
+#include "swift/Runtime/Config.h"
+#include "../SwiftShims/FoundationShims.h"
+#include <stdlib.h>
+
+#if defined(__APPLE__) && defined(__MACH__)
+
+#if SWIFT_CLASS_IS_SWIFT_MASK_GLOBAL_VARIABLE
+static unsigned long long computeIsSwiftMask() {
+  if (swift::_swift_isBackDeploying())
+    return 1ULL;
+  return 2ULL;
+}
+
+SWIFT_ALLOWED_RUNTIME_GLOBAL_CTOR_BEGIN
+extern "C" unsigned long long
+_swift_classIsSwiftMask = computeIsSwiftMask();
+SWIFT_ALLOWED_RUNTIME_GLOBAL_CTOR_END
+#endif // SWIFT_CLASS_IS_SWIFT_MASK_GLOBAL_VARIABLE
+
+static swift::_SwiftNSOperatingSystemVersion swiftInOSVersion = {
+#if __MAC_OS_X_VERSION_MIN_REQUIRED
+  10, 14, 4
+// WatchOS also pretends to be iOS, so check it first.
+#elif __WATCH_OS_VERSION_MIN_REQUIRED
+   5,  2, 0
+#elif __IPHONE_OS_VERSION_MIN_REQUIRED || __TV_OS_VERSION_MIN_REQUIRED
+  12,  2, 0
+#else
+  9999, 0, 0
+#endif
+};
+
+static bool versionLessThan(swift::_SwiftNSOperatingSystemVersion lhs,
+                            swift::_SwiftNSOperatingSystemVersion rhs) {
+  if (lhs.majorVersion < rhs.majorVersion) return true;
+  if (lhs.majorVersion > rhs.majorVersion) return false;
+  
+  if (lhs.minorVersion < rhs.minorVersion) return true;
+  if (lhs.minorVersion > rhs.minorVersion) return false;
+  
+  if (lhs.patchVersion < rhs.patchVersion) return true;
+  
+  return false;
+}
+
+SWIFT_RUNTIME_STDLIB_INTERNAL
+int _swift_isBackDeploying() {
+  auto version = swift::_swift_stdlib_operatingSystemVersion();
+  return versionLessThan(version, swiftInOSVersion);
+}
+#endif

trunk/stdlib/public/runtime/CMakeLists.txt

@@ -31,6 +31,7 @@ set(swift_runtime_objc_sources
 set(swift_runtime_sources
     AnyHashableSupport.cpp
     Array.cpp
+    BackDeployment.cpp
     Casting.cpp
     CompatibilityOverride.cpp
     CygwinPort.cpp

trunk/stdlib/public/runtime/Metadata.cpp

@@ -96,7 +96,15 @@ Metadata *TargetSingletonMetadataInitialization<InProcess>::allocate(
   // If this is a class, we have to initialize the value witness table early
   // so that two-phase initialization can proceed as if this metadata is
   // complete for layout purposes when it appears as part of an aggregate type.
-  if (auto *classMetadata = dyn_cast<ClassMetadata>(metadata)) {
+  //
+  // Note that we can't use (dyn_)cast<ClassMetadata> here because the static
+  // template may have the "wrong" isSwift bit set in its Data pointer, if the
+  // binary was built to deploy back to pre-stable-Swift Objective-C runtimes.
+  // Such a template will fail the `isTypeMetadata` test and we'll think that it
+  // isn't Swift metadata but a plain old ObjC class instead.
+  if (metadata->getKind() == MetadataKind::Class) {
+    auto *classMetadata = static_cast<ClassMetadata*>(metadata);
+    classMetadata->setAsTypeMetadata();
     auto *fullMetadata = asFullMetadata(metadata);
 
     // Begin by initializing the value witness table; everything else is