Merge pull request #3666 from swiftwasm/release/5.5

[pull] swiftwasm-release/5.5 from release/5.5

Author: pull[bot]

include/swift/Basic/Platform.h

@@ -55,9 +55,10 @@ namespace swift {
   bool triplesAreValidForZippering(const llvm::Triple &target,
                                    const llvm::Triple &targetVariant);
 
-  /// Returns true if the given triple represents an OS that ships with
-  /// ABI-stable swift libraries (eg. in /usr/lib/swift).
-  bool tripleRequiresRPathForSwiftInOS(const llvm::Triple &triple);
+  /// Returns true if the given triple represents an OS that has all the
+  /// "built-in" ABI-stable libraries (stdlib and _Concurrency)
+  /// (eg. in /usr/lib/swift).
+  bool tripleRequiresRPathForSwiftLibrariesInOS(const llvm::Triple &triple);
 
   /// Returns the platform name for a given target triple.
   ///

include/swift/Runtime/BackDeployment.h

@@ -100,34 +100,21 @@
 /// from ObjC classes?
 #ifndef SWIFT_CLASS_IS_SWIFT_MASK
 
-// 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
-
-// Builds for Xcode always use 1.
-# elif SWIFT_BNI_XCODE_BUILD
-#  define SWIFT_CLASS_IS_SWIFT_MASK 1ULL
-
 // Compatibility hook libraries cannot rely on the "is swift" bit being either
 // value, since they must work with both OS and Xcode versions of the libraries.
 // Generate a reference to a nonexistent symbol so that we get obvious linker
 // errors if we try.
-# elif SWIFT_COMPATIBILITY_LIBRARY
+# if SWIFT_COMPATIBILITY_LIBRARY
 extern uintptr_t __COMPATIBILITY_LIBRARIES_CANNOT_CHECK_THE_IS_SWIFT_BIT_DIRECTLY__;
 #  define SWIFT_CLASS_IS_SWIFT_MASK __COMPATIBILITY_LIBRARIES_CANNOT_CHECK_THE_IS_SWIFT_BIT_DIRECTLY__
 
-// Other builds (such as local builds on developers' computers)
-// dynamically choose the bit at runtime based on the current OS
-// version.
+// Apple platforms always use 2
+# elif defined(__APPLE__)
+#  define SWIFT_CLASS_IS_SWIFT_MASK 2ULL
+
+// Non-Apple platforms always use 1.
 # else
-#  define SWIFT_CLASS_IS_SWIFT_MASK _swift_classIsSwiftMask
-#  define SWIFT_CLASS_IS_SWIFT_MASK_GLOBAL_VARIABLE 1
-#  define SWIFT_BUILD_HAS_BACK_DEPLOYMENT 1
-#  include "BackDeployment.h"
+#  define SWIFT_CLASS_IS_SWIFT_MASK 1ULL
 
 # endif
 #endif

include/swift/Runtime/Config.h

@@ -1124,6 +1124,12 @@ FUNCTION(LookUpClass, objc_lookUpClass, C_CC, AlwaysAvailable,
          ARGS(Int8PtrTy),
          ATTRS(NoUnwind, ReadNone))
 
+// Class objc_setSuperclass(Class cls, Class newSuper);
+FUNCTION(SetSuperclass, class_setSuperclass, C_CC, AlwaysAvailable,
+         RETURNS(ObjCClassPtrTy),
+         ARGS(ObjCClassPtrTy, ObjCClassPtrTy),
+         ATTRS(NoUnwind))
+
 // Metadata *swift_getObjectType(id object);
 FUNCTION(GetObjectType, swift_getObjectType, C_CC, AlwaysAvailable,
          RETURNS(TypeMetadataPtrTy),
@@ -1384,6 +1390,10 @@ FUNCTION(ObjCGetClass, objc_getClass, C_CC,  AlwaysAvailable,
          RETURNS(ObjCClassPtrTy),
          ARGS(Int8PtrTy),
          ATTRS(NoUnwind))
+FUNCTION(ObjCGetRequiredClass, objc_getRequiredClass, C_CC,  AlwaysAvailable,
+         RETURNS(ObjCClassPtrTy),
+         ARGS(Int8PtrTy),
+         ATTRS(NoUnwind))
 FUNCTION(ObjCGetMetaClass, objc_getMetaClass, C_CC, AlwaysAvailable,
          RETURNS(ObjCClassPtrTy),
          ARGS(Int8PtrTy),

include/swift/Runtime/RuntimeFunctions.def

@@ -79,19 +79,25 @@ bool swift::triplesAreValidForZippering(const llvm::Triple &target,
   return false;
 }
 
-bool swift::tripleRequiresRPathForSwiftInOS(const llvm::Triple &triple) {
+bool swift::tripleRequiresRPathForSwiftLibrariesInOS(
+    const llvm::Triple &triple) {
   if (triple.isMacOSX()) {
-    // macOS 10.14.4 contains a copy of Swift, but the linker will still use an
-    // rpath-based install name until 10.15.
-    return triple.isMacOSXVersionLT(10, 15);
+    // macOS versions before 10.14.4 don't have Swift in the OS
+    // (the linker still uses an rpath-based install name until 10.15).
+    // macOS versions before 12.0 don't have _Concurrency in the OS.
+    return triple.isMacOSXVersionLT(12, 0);
   }
 
   if (triple.isiOS()) {
-    return triple.isOSVersionLT(12, 2);
+    // iOS versions before 12.2 don't have Swift in the OS.
+    // iOS versions before 15.0 don't have _Concurrency in the OS.
+    return triple.isOSVersionLT(15, 0);
   }
 
   if (triple.isWatchOS()) {
-    return triple.isOSVersionLT(5, 2);
+    // watchOS versions before 5.2 don't have Swift in the OS.
+    // watchOS versions before 8.0 don't have _Concurrency in the OS.
+    return triple.isOSVersionLT(8, 0);
   }
 
   // Other platforms don't have Swift installed as part of the OS by default.

lib/Basic/Platform.cpp

@@ -452,7 +452,7 @@ toolchains::Darwin::addArgsToLinkStdlib(ArgStringList &Arguments,
       Arguments.push_back("-rpath");
       Arguments.push_back(context.Args.MakeArgString(path));
     }
-  } else if (!tripleRequiresRPathForSwiftInOS(getTriple()) ||
+  } else if (!tripleRequiresRPathForSwiftLibrariesInOS(getTriple()) ||
              context.Args.hasArg(options::OPT_no_stdlib_rpath)) {
     // If targeting an OS with Swift in /usr/lib/swift, the LC_ID_DYLIB
     // install_name the stdlib will be an absolute path like
@@ -480,9 +480,11 @@ toolchains::Darwin::addArgsToLinkStdlib(ArgStringList &Arguments,
     // package isn't installed.
     Arguments.push_back("-rpath");
     Arguments.push_back(context.Args.MakeArgString("/usr/lib/swift"));
-    // We don't need an rpath for /System/iOSSupport/usr/lib/swift because...
-    assert(!tripleIsMacCatalystEnvironment(getTriple())
-           && "macCatalyst not supported without Swift-in-the-OS");
+    // We don’t need an rpath for /System/iOSSupport/usr/lib/swift because:
+    // 1. The standard library and overlays were part of the OS before
+    //    Catalyst was introduced, so they are always available for Catalyst.
+    // 2. The _Concurrency back-deployment library is zippered, whereas only
+    //    unzippered frameworks need an unzippered twin in /System/iOSSupport.
   }
 }
 

lib/Driver/DarwinToolChains.cpp

@@ -1884,7 +1884,7 @@ static void printTripleInfo(const llvm::Triple &triple,
   }
 
   out << "    \"librariesRequireRPath\": "
-      << (tripleRequiresRPathForSwiftInOS(triple) ? "true" : "false")
+      << (tripleRequiresRPathForSwiftLibrariesInOS(triple) ? "true" : "false")
       << "\n";
 
   out << "  }";

lib/FrontendTool/FrontendTool.cpp

@@ -960,6 +960,7 @@ void IRGenModule::emitClassDecl(ClassDecl *D) {
   emitFieldDescriptor(D);
 
   IRGen.addClassForEagerInitialization(D);
+  IRGen.addBackDeployedObjCActorInitialization(D);
 
   emitNestedTypeDecls(D->getMembers());
 }
@@ -2527,15 +2528,24 @@ ClassDecl *irgen::getRootClassForMetaclass(IRGenModule &IGM, ClassDecl *C) {
 
 ClassDecl *
 irgen::getSuperclassDeclForMetadata(IRGenModule &IGM, ClassDecl *C) {
-  if (C->isNativeNSObjectSubclass())
+  if (C->isNativeNSObjectSubclass()) {
+    // When concurrency isn't available in the OS, use NSObject instead.
+    if (!IGM.isConcurrencyAvailable()) {
+      return IGM.getObjCRuntimeBaseClass(
+          IGM.Context.getSwiftId(KnownFoundationEntity::NSObject),
+          IGM.Context.getIdentifier("NSObject"));
+    }
+
     return IGM.getSwiftNativeNSObjectDecl();
+  }
   return C->getSuperclassDecl();
 }
 
 CanType irgen::getSuperclassForMetadata(IRGenModule &IGM, ClassDecl *C) {
-  if (C->isNativeNSObjectSubclass())
-    return IGM.getSwiftNativeNSObjectDecl()->getDeclaredInterfaceType()
-                                           ->getCanonicalType();
+  if (C->isNativeNSObjectSubclass()) {
+    return getSuperclassDeclForMetadata(IGM, C)->getDeclaredInterfaceType()
+                                               ->getCanonicalType();
+  }
   if (auto superclass = C->getSuperclass())
     return superclass->getCanonicalType();
   return CanType();
@@ -2544,9 +2554,10 @@ CanType irgen::getSuperclassForMetadata(IRGenModule &IGM, ClassDecl *C) {
 CanType irgen::getSuperclassForMetadata(IRGenModule &IGM, CanType type,
                                         bool useArchetypes) {
   auto cls = type->getClassOrBoundGenericClass();
-  if (cls->isNativeNSObjectSubclass())
-    return IGM.getSwiftNativeNSObjectDecl()->getDeclaredInterfaceType()
-                                           ->getCanonicalType();
+  if (cls->isNativeNSObjectSubclass()) {
+    return getSuperclassDeclForMetadata(IGM, cls)->getDeclaredInterfaceType()
+                                                 ->getCanonicalType();
+  }
   if (auto superclass = type->getSuperclass(useArchetypes))
     return superclass->getCanonicalType();
   return CanType();

lib/IRGen/GenClass.cpp

@@ -1932,6 +1932,48 @@ void IRGenerator::emitEagerClassInitialization() {
   llvm::appendToGlobalCtors(IGM->Module, RegisterFn, 60000, nullptr);
 }
 
+void IRGenerator::emitObjCActorsNeedingSuperclassSwizzle() {
+  if (ObjCActorsNeedingSuperclassSwizzle.empty())
+    return;
+
+  // Emit the register function in the primary module.
+  IRGenModule *IGM = getPrimaryIGM();
+
+  llvm::Function *RegisterFn = llvm::Function::Create(
+                                llvm::FunctionType::get(IGM->VoidTy, false),
+                                llvm::GlobalValue::PrivateLinkage,
+                                "_swift_objc_actor_initialization");
+  IGM->Module.getFunctionList().push_back(RegisterFn);
+  IRGenFunction RegisterIGF(*IGM, RegisterFn);
+  RegisterFn->setAttributes(IGM->constructInitialAttributes());
+  RegisterFn->setCallingConv(IGM->DefaultCC);
+
+  // Look up the SwiftNativeNSObject class.
+  auto swiftNativeNSObjectName =
+      IGM->getAddrOfGlobalString("SwiftNativeNSObject");
+  auto swiftNativeNSObjectClass = RegisterIGF.Builder.CreateCall(
+      RegisterIGF.IGM.getObjCGetRequiredClassFn(), swiftNativeNSObjectName);
+
+  for (ClassDecl *CD : ObjCActorsNeedingSuperclassSwizzle) {
+    // The @objc actor class.
+    llvm::Value *classRef = RegisterIGF.emitTypeMetadataRef(
+        CD->getDeclaredInterfaceType()->getCanonicalType());
+    classRef = RegisterIGF.Builder.CreateBitCast(classRef, IGM->ObjCClassPtrTy);
+
+    // Set its superclass to SwiftNativeNSObject.
+    RegisterIGF.Builder.CreateCall(
+        RegisterIGF.IGM.getSetSuperclassFn(),
+        { classRef, swiftNativeNSObjectClass});
+  }
+  RegisterIGF.Builder.CreateRetVoid();
+
+  // Add the registration function as a static initializer. We use a priority
+  // slightly lower than used for C++ global constructors, so that the code is
+  // executed before C++ global constructors (in case someone manages to access
+  // an @objc actor from a global constructor).
+  llvm::appendToGlobalCtors(IGM->Module, RegisterFn, 60000, nullptr);
+}
+
 /// Emit symbols for eliminated dead methods, which can still be referenced
 /// from other modules. This happens e.g. if a public class contains a (dead)
 /// private method.

lib/IRGen/GenDecl.cpp

@@ -178,7 +178,15 @@ getRuntimeVersionThatSupportsDemanglingType(CanType type) {
   // related to concurrency.
   bool needsConcurrency = type.findIf([](CanType t) -> bool {
     if (auto fn = dyn_cast<AnyFunctionType>(t)) {
-      return fn->isAsync() || fn->isSendable() || fn->hasGlobalActor();
+      if (fn->isAsync() || fn->isSendable() || fn->hasGlobalActor())
+        return true;
+
+      for (const auto param: fn->getParams()) {
+        if (param.isIsolated())
+          return true;
+      }
+
+      return false;
     }
     return false;
   });