Merge pull request #66857 from Catfish-Man/revert-bridge-flip

gottesmm · web-flow · commit 3202021cd045 · 2023-06-22T10:50:14.000-07:00
Revert [Runtime] Let CF provide us with state, avoiding runtime lookup
diff --git a/stdlib/public/SwiftShims/swift/shims/CoreFoundationShims.h b/stdlib/public/SwiftShims/swift/shims/CoreFoundationShims.h
@@ -74,10 +74,7 @@ _swift_stdlib_NSStringGetCStringTrampoline(id _Nonnull obj,
 SWIFT_RUNTIME_STDLIB_API
 __swift_uint8_t
 _swift_stdlib_dyld_is_objc_constant_string(const void * _Nonnull addr);
-
-/// Get the NSError Objective-C class.
-_Nullable Class getNSErrorClass();
-
+  
 #endif // __OBJC2__
 
 #ifdef __cplusplus
diff --git a/stdlib/public/runtime/ErrorObject.mm b/stdlib/public/runtime/ErrorObject.mm
@@ -185,6 +185,10 @@ - (BOOL)isEqual:(id)other {
 
 @end
 
+Class swift::getNSErrorClass() {
+  return SWIFT_LAZY_CONSTANT(objc_lookUpClass("NSError"));
+}
+
 const Metadata *swift::getNSErrorMetadata() {
   return SWIFT_LAZY_CONSTANT(
     swift_getObjCClassMetadata((const ClassMetadata *)getNSErrorClass()));
@@ -216,8 +220,16 @@ - (BOOL)isEqual:(id)other {
 }
 
 static Class getAndBridgeSwiftNativeNSErrorClass() {
-  (void)getNSErrorClass(); //make sure the bridge is set up
-  return [__SwiftNativeNSError class];
+  Class nsErrorClass = swift::getNSErrorClass();
+  Class ourClass = [__SwiftNativeNSError class];
+  // We want "err as AnyObject" to do *something* even without Foundation
+  if (nsErrorClass) {
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wdeprecated-declarations"
+      class_setSuperclass(ourClass, nsErrorClass);
+    #pragma clang diagnostic pop
+  }
+  return ourClass;
 }
 
 static Class getSwiftNativeNSErrorClass() {
diff --git a/stdlib/public/runtime/SwiftObject.mm b/stdlib/public/runtime/SwiftObject.mm
@@ -1086,7 +1086,6 @@ static bool isObjCForUnownedReference(void *value) {
 /*****************************************************************************/
 
 #if SWIFT_OBJC_INTEROP
-
 static const void *
 swift_dynamicCastObjCClassImpl(const void *object,
                                const ClassMetadata *targetType) {
diff --git a/stdlib/public/stubs/FoundationHelpers.mm b/stdlib/public/stubs/FoundationHelpers.mm
@@ -24,150 +24,60 @@
 #import <objc/runtime.h>
 #include "swift/Runtime/Once.h"
 #include <dlfcn.h>
-#include "swift/Runtime/Atomic.h"
 
 typedef enum {
     dyld_objc_string_kind
 } DyldObjCConstantKind;
 
 using namespace swift;
 
-typedef struct _CFBridgingState {
-  long version;
-  CFHashCode(*_CFStringHashCString)(const uint8_t *bytes, CFIndex len);
-  CFHashCode(*_CFStringHashNSString)(id str);
-  CFTypeID(*_CFGetTypeID)(CFTypeRef obj);
-  CFTypeID _CFStringTypeID = 0;
-  Class NSErrorClass;
-  Class NSStringClass;
-  Class NSArrayClass;
-  Class NSMutableArrayClass;
-  Class NSSetClass;
-  Class NSDictionaryClass;
-  Class NSEnumeratorClass;
-  //version 0 ends here
-} CFBridgingState;
-
-static std::atomic<CFBridgingState const *> bridgingState;
-static swift_once_t initializeBridgingStateOnce;
-
-static CFBridgingState const *getBridgingState() {
-  return bridgingState.load(SWIFT_MEMORY_ORDER_CONSUME);
-}
+static CFHashCode(*_CFStringHashCString)(const uint8_t *bytes, CFIndex len);
+static CFHashCode(*_CFStringHashNSString)(id str);
+static CFTypeID(*_CFGetTypeID)(CFTypeRef obj);
+static CFTypeID _CFStringTypeID = 0;
+static swift_once_t initializeBridgingFuncsOnce;
 
 extern "C" bool _dyld_is_objc_constant(DyldObjCConstantKind kind,
                                        const void *addr) SWIFT_RUNTIME_WEAK_IMPORT;
 
-@class __SwiftNativeNSStringBase, __SwiftNativeNSError, __SwiftNativeNSArrayBase, __SwiftNativeNSMutableArrayBase, __SwiftNativeNSDictionaryBase, __SwiftNativeNSSetBase, __SwiftNativeNSEnumeratorBase;
-
-static void _reparentClasses() {
-  auto state = getBridgingState();
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-  if (state->NSStringClass) {
-    [state->NSStringClass class]; //make sure the class is realized
-    class_setSuperclass([__SwiftNativeNSStringBase class],  state->NSStringClass);
-  }
-  if (state->NSErrorClass) {
-    [state->NSErrorClass class]; //make sure the class is realized
-    class_setSuperclass([__SwiftNativeNSError class], state->NSErrorClass);
-  }
-  if (state->NSArrayClass) {
-    [state->NSArrayClass class]; //make sure the class is realized
-    class_setSuperclass([__SwiftNativeNSArrayBase class],  state->NSArrayClass);
-  }
-  if (state->NSMutableArrayClass) {
-    [state->NSMutableArrayClass class]; //make sure the class is realized
-    class_setSuperclass([__SwiftNativeNSMutableArrayBase class],  state->NSMutableArrayClass);
-  }
-  if (state->NSDictionaryClass) {
-    [state->NSDictionaryClass class]; //make sure the class is realized
-    class_setSuperclass([__SwiftNativeNSDictionaryBase class],  state->NSDictionaryClass);
-  }
-  if (state->NSSetClass) {
-    [state->NSSetClass class]; //make sure the class is realized
-    class_setSuperclass([__SwiftNativeNSSetBase class],  state->NSSetClass);
-  }
-  if (state->NSEnumeratorClass) {
-    [state->NSEnumeratorClass class]; //make sure the class is realized
-    class_setSuperclass([__SwiftNativeNSEnumeratorBase class],  state->NSEnumeratorClass);
-  }
-#pragma clang diagnostic pop
-}
-
-static inline bool initializeBridgingFunctions() {
-  swift::once(initializeBridgingStateOnce, [](){
-    assert(!getBridgingState());
-    auto getStringTypeID = (CFTypeID(*)(void))dlsym(RTLD_DEFAULT, "CFStringGetTypeID");
-    if (!getStringTypeID) {
-      return; //CF not loaded
-    }
-    auto state = (CFBridgingState *)calloc(1, sizeof(CFBridgingState));
-    state->version = 0;
-    state->_CFStringTypeID = getStringTypeID();
-    state->_CFGetTypeID = (CFTypeID(*)(CFTypeRef obj))dlsym(RTLD_DEFAULT, "CFGetTypeID");
-    state->_CFStringHashNSString = (CFHashCode(*)(id))dlsym(RTLD_DEFAULT, "CFStringHashNSString");
-    state->_CFStringHashCString = (CFHashCode(*)(const uint8_t *, CFIndex))dlsym(RTLD_DEFAULT, "CFStringHashCString");
-    state->NSErrorClass = objc_lookUpClass("NSError");
-    state->NSStringClass = objc_lookUpClass("NSString");
-    state->NSArrayClass = objc_lookUpClass("NSArray");
-    state->NSMutableArrayClass = objc_lookUpClass("NSMutableArray");
-    state->NSSetClass = objc_lookUpClass("NSSet");
-    state->NSDictionaryClass = objc_lookUpClass("NSDictionary");
-    state->NSEnumeratorClass = objc_lookUpClass("NSEnumerator");
-    bridgingState.store(state, std::memory_order_relaxed);
-    _reparentClasses();
-  });
-  auto state = getBridgingState();
-  return state && state->NSStringClass != nullptr;
-}
-
-SWIFT_RUNTIME_EXPORT void swift_initializeCoreFoundationState(CFBridgingState const * const state) {
-  //Consume the once token to make sure that the lazy version of this in initializeBridgingFunctions only runs if we didn't hit this
-  swift::once(initializeBridgingStateOnce, [state](){
-    bridgingState.store(state, std::memory_order_relaxed);
-  });
-  //It's fine if this runs more than once, it's a noop if it's been done before
-  //and we want to make sure it still happens if CF loads late after it failed initially
-  bridgingState.store(state, std::memory_order_release);
-  _reparentClasses();
-}
-
-namespace swift {
-Class getNSErrorClass();
-}
-
-Class swift::getNSErrorClass() {
-  if (initializeBridgingFunctions()) {
-    return getBridgingState()->NSErrorClass;
-  }
-  return nullptr;
+static void _initializeBridgingFunctionsImpl(void *ctxt) {
+  auto getStringTypeID =
+    (CFTypeID(*)(void))
+    dlsym(RTLD_DEFAULT, "CFStringGetTypeID");
+  assert(getStringTypeID);
+  _CFStringTypeID = getStringTypeID();
+  
+  _CFGetTypeID = (CFTypeID(*)(CFTypeRef obj))dlsym(RTLD_DEFAULT, "CFGetTypeID");
+  _CFStringHashNSString = (CFHashCode(*)(id))dlsym(RTLD_DEFAULT,
+                                                   "CFStringHashNSString");
+  _CFStringHashCString = (CFHashCode(*)(const uint8_t *, CFIndex))dlsym(
+                                                   RTLD_DEFAULT,
+                                                   "CFStringHashCString");
 }
 
-SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_SPI
-bool
-swift_stdlib_connectNSBaseClasses() {
-  return initializeBridgingFunctions();
+static inline void initializeBridgingFunctions() {
+  swift_once(&initializeBridgingFuncsOnce,
+             _initializeBridgingFunctionsImpl,
+             nullptr);
 }
 
 __swift_uint8_t
 _swift_stdlib_isNSString(id obj) {
-  assert(initializeBridgingFunctions());
-  auto state = getBridgingState();
-  return state->_CFGetTypeID((CFTypeRef)obj) == state->_CFStringTypeID ? 1 : 0;
+  initializeBridgingFunctions();
+  return _CFGetTypeID((CFTypeRef)obj) == _CFStringTypeID ? 1 : 0;
 }
 
 _swift_shims_CFHashCode
 _swift_stdlib_CFStringHashNSString(id _Nonnull obj) {
-  assert(initializeBridgingFunctions());
-  return getBridgingState()->_CFStringHashNSString(obj);
+  initializeBridgingFunctions();
+  return _CFStringHashNSString(obj);
 }
 
 _swift_shims_CFHashCode
 _swift_stdlib_CFStringHashCString(const _swift_shims_UInt8 * _Nonnull bytes,
                                   _swift_shims_CFIndex length) {
-  assert(initializeBridgingFunctions());
-  return getBridgingState()->_CFStringHashCString(bytes, length);
+  initializeBridgingFunctions();
+  return _CFStringHashCString(bytes, length);
 }
 
 const __swift_uint8_t *
diff --git a/stdlib/public/stubs/SwiftNativeNSXXXBase.mm.gyb b/stdlib/public/stubs/SwiftNativeNSXXXBase.mm.gyb
@@ -87,6 +87,22 @@ swift_stdlib_NSObject_isEqual(id lhs,
   return (lhs == rhs) || [lhs isEqual:rhs];
 }
 
+SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_SPI
+bool
+swift_stdlib_connectNSBaseClasses() {
+% for Class in ('Array', 'MutableArray', 'Dictionary', 'Set', 'String', 'Enumerator'):
+  Class NS${Class}Super = objc_lookUpClass("NS${Class}");
+  if (!NS${Class}Super) return false;
+  Class NS${Class}OurClass = objc_lookUpClass("__SwiftNativeNS${Class}Base");
+  if (!NS${Class}OurClass) return false;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+  class_setSuperclass(NS${Class}OurClass, NS${Class}Super);
+#pragma clang diagnostic pop
+% end
+  return true;
+}
+
 #endif
 
 // ${'Local Variables'}:
diff --git a/unittests/runtime/CMakeLists.txt b/unittests/runtime/CMakeLists.txt
@@ -40,14 +40,6 @@ if(("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "${SWIFT_PRIMARY_VARIANT_SDK}") AND
 
   set(PLATFORM_SOURCES)
   set(PLATFORM_TARGET_LINK_LIBRARIES)
-  set(PLATFORM_TARGET_RUNTIME_ARCHIVES)
-  
-  list(APPEND PLATFORM_TARGET_RUNTIME_ARCHIVES
-    $<TARGET_OBJECTS:swiftRuntime${SWIFT_PRIMARY_VARIANT_SUFFIX}>
-    $<TARGET_OBJECTS:swiftLLVMSupport${SWIFT_PRIMARY_VARIANT_SUFFIX}>
-    $<TARGET_OBJECTS:swiftDemangling${SWIFT_PRIMARY_VARIANT_SUFFIX}>
-    )
-
   if(SWIFT_HOST_VARIANT MATCHES "${SWIFT_DARWIN_VARIANTS}")
     find_library(FOUNDATION_LIBRARY Foundation)
     list(APPEND PLATFORM_SOURCES
@@ -61,9 +53,6 @@ if(("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "${SWIFT_PRIMARY_VARIANT_SDK}") AND
       swift_Concurrency${SWIFT_PRIMARY_VARIANT_SUFFIX}
       swiftStdlibUnittest${SWIFT_PRIMARY_VARIANT_SUFFIX}
       )
-    list(APPEND PLATFORM_TARGET_RUNTIME_ARCHIVES
-      $<TARGET_OBJECTS:swiftStdlibStubs${SWIFT_PRIMARY_VARIANT_SUFFIX}>
-      )
   elseif(SWIFT_HOST_VARIANT STREQUAL "Linux")
     if(SWIFT_HOST_VARIANT_ARCH MATCHES "armv6|armv7|i686")
       list(APPEND PLATFORM_TARGET_LINK_LIBRARIES
@@ -127,7 +116,9 @@ if(("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "${SWIFT_PRIMARY_VARIANT_SDK}") AND
     # The runtime tests link to internal runtime symbols, which aren't exported
     # from the swiftCore dylib, so we need to link to both the runtime archive
     # and the stdlib.
-    ${PLATFORM_TARGET_RUNTIME_ARCHIVES}
+    $<TARGET_OBJECTS:swiftRuntime${SWIFT_PRIMARY_VARIANT_SUFFIX}>
+    $<TARGET_OBJECTS:swiftLLVMSupport${SWIFT_PRIMARY_VARIANT_SUFFIX}>
+    $<TARGET_OBJECTS:swiftDemangling${SWIFT_PRIMARY_VARIANT_SUFFIX}>
     )
 
   # The local stdlib implementation provides definitions of the swiftCore
diff --git a/unittests/runtime/LongTests/CMakeLists.txt b/unittests/runtime/LongTests/CMakeLists.txt
@@ -3,18 +3,8 @@ if(("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "${SWIFT_PRIMARY_VARIANT_SDK}") AND
 
   set(PLATFORM_SOURCES)
   set(PLATFORM_TARGET_LINK_LIBRARIES)
-  set(PLATFORM_TARGET_RUNTIME_ARCHIVES)
-  
-  list(APPEND PLATFORM_TARGET_RUNTIME_ARCHIVES
-    $<TARGET_OBJECTS:swiftRuntime${SWIFT_PRIMARY_VARIANT_SUFFIX}>
-    $<TARGET_OBJECTS:swiftLLVMSupport${SWIFT_PRIMARY_VARIANT_SUFFIX}>
-    $<TARGET_OBJECTS:swiftDemangling${SWIFT_PRIMARY_VARIANT_SUFFIX}>
-    )
 
   if(SWIFT_HOST_VARIANT MATCHES "${SWIFT_DARWIN_VARIANTS}")
-    list(APPEND PLATFORM_TARGET_RUNTIME_ARCHIVES
-      $<TARGET_OBJECTS:swiftStdlibStubs${SWIFT_PRIMARY_VARIANT_SUFFIX}>
-      )
 #   Placeholder for Darwin Foundation tests (currently none)
 #    find_library(FOUNDATION_LIBRARY Foundation)
 #    list(APPEND PLATFORM_SOURCES
@@ -52,7 +42,9 @@ if(("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "${SWIFT_PRIMARY_VARIANT_SDK}") AND
     # The runtime tests link to internal runtime symbols, which aren't exported
     # from the swiftCore dylib, so we need to link to both the runtime archive
     # and the stdlib.
-    ${PLATFORM_TARGET_RUNTIME_ARCHIVES}
+    $<TARGET_OBJECTS:swiftRuntime${SWIFT_PRIMARY_VARIANT_SUFFIX}>
+    $<TARGET_OBJECTS:swiftLLVMSupport${SWIFT_PRIMARY_VARIANT_SUFFIX}>
+    $<TARGET_OBJECTS:swiftDemangling${SWIFT_PRIMARY_VARIANT_SUFFIX}>
     )
 
   # The local stdlib implementation provides definitions of the swiftCore
