Merge pull request #37884 from al45tair/problem/64939529

<rdar://64939529> Convert unnecessary dlsym() calls into direct refs

Author: al45tair

include/swift/Runtime/Config.h

@@ -20,6 +20,39 @@
 #include "swift/Basic/Compiler.h"
 #include "swift/Runtime/CMakeConfig.h"
 
+/// SWIFT_RUNTIME_WEAK_IMPORT - Marks a symbol for weak import.
+#if (__has_attribute(weak_import))
+#define SWIFT_RUNTIME_WEAK_IMPORT __attribute__((weak_import))
+#else
+#define SWIFT_RUNTIME_WEAK_IMPORT
+#endif
+
+/// SWIFT_RUNTIME_WEAK_CHECK - Tests if a potentially weakly linked function
+/// is linked into the runtime.  This is useful on Apple platforms where it is
+/// possible that system functions are only available on newer versions.
+#ifdef __clang__
+#define SWIFT_RUNTIME_WEAK_CHECK(x)                                     \
+  _Pragma("clang diagnostic push")                                      \
+  _Pragma("clang diagnostic ignored \"-Wunguarded-availability\"")      \
+  _Pragma("clang diagnostic ignored \"-Wunguarded-availability-new\"")  \
+  (&x)                                                                  \
+  _Pragma("clang diagnostic pop")
+#else
+#define SWIFT_RUNTIME_WEAK_CHECK(x) &x
+#endif
+
+/// SWIFT_RUNTIME_WEAK_USE - Use a potentially weakly imported symbol.
+#ifdef __clang__
+#define SWIFT_RUNTIME_WEAK_USE(x)                                       \
+  _Pragma("clang diagnostic push")                                      \
+  _Pragma("clang diagnostic ignored \"-Wunguarded-availability\"")      \
+  _Pragma("clang diagnostic ignored \"-Wunguarded-availability-new\"")  \
+  (x)                                                                   \
+  _Pragma("clang diagnostic pop")
+#else
+#define SWIFT_RUNTIME_WEAK_USE(x) x
+#endif
+
 /// SWIFT_RUNTIME_LIBRARY_VISIBILITY - If a class marked with this attribute is
 /// linked into a shared library, then the class should be private to the
 /// library and not accessible from outside it.  Can also be used to mark

stdlib/public/runtime/HeapObject.cpp

@@ -694,24 +694,22 @@ void swift::swift_rootObjCDealloc(HeapObject *self) {
 }
 #endif
 
-#if SWIFT_OBJC_INTEROP
-static bool _check_fast_dealloc() {
-  return dlsym(RTLD_NEXT, "_objc_has_weak_formation_callout") != nullptr;
-}
-#endif
-
 void swift::swift_deallocClassInstance(HeapObject *object,
                                        size_t allocatedSize,
                                        size_t allocatedAlignMask) {
-  
 #if SWIFT_OBJC_INTEROP
   // We need to let the ObjC runtime clean up any associated objects or weak
   // references associated with this object.
-  const bool fastDeallocSupported = SWIFT_LAZY_CONSTANT(_check_fast_dealloc());
+#if !TARGET_OS_SIMULATOR || !__x86_64__
+  const bool fastDeallocSupported = true;
+#else
+  const bool fastDeallocSupported = false;
+#endif
   if (!fastDeallocSupported || !object->refCounts.getPureSwiftDeallocation()) {
     objc_destructInstance((id)object);
   }
 #endif
+
   swift_deallocObject(object, allocatedSize, allocatedAlignMask);
 }
 

stdlib/public/runtime/Metadata.cpp

@@ -2580,14 +2580,6 @@ static void initGenericClassObjCName(ClassMetadata *theClass) {
 }
 
 static bool installLazyClassNameHook() {
-#if !OBJC_SETHOOK_LAZYCLASSNAMER_DEFINED
-  using objc_hook_lazyClassNamer =
-    const char * _Nullable (*)(_Nonnull Class cls);
-  auto objc_setHook_lazyClassNamer =
-    (void (*)(objc_hook_lazyClassNamer, objc_hook_lazyClassNamer *))
-    dlsym(RTLD_NEXT, "objc_setHook_lazyClassNamer");  
-#endif
-
   static objc_hook_lazyClassNamer oldHook;
   auto myHook = [](Class theClass) -> const char * {
     ClassMetadata *metadata = (ClassMetadata *)theClass;
@@ -2596,14 +2588,12 @@ static bool installLazyClassNameHook() {
     return oldHook(theClass);
   };
 
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunguarded-availability"
-  if (objc_setHook_lazyClassNamer == nullptr)
-    return false;
-  objc_setHook_lazyClassNamer(myHook, &oldHook);
-#pragma clang diagnostic pop
+  if (SWIFT_RUNTIME_WEAK_CHECK(objc_setHook_lazyClassNamer)) {
+    SWIFT_RUNTIME_WEAK_USE(objc_setHook_lazyClassNamer(myHook, &oldHook));
+    return true;
+  }
 
-  return true;
+  return false;
 }
 
 __attribute__((constructor)) SWIFT_RUNTIME_ATTRIBUTE_ALWAYS_INLINE static bool
@@ -3077,11 +3067,6 @@ getSuperclassMetadata(ClassMetadata *self, bool allowDependency) {
   return {MetadataDependency(), second};
 }
 
-// Suppress diagnostic about the availability of _objc_realizeClassFromSwift.
-// We test availability with a nullptr check, but the compiler doesn't see that.
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunguarded-availability-new"
-
 static SWIFT_CC(swift) MetadataDependency
 _swift_initClassMetadataImpl(ClassMetadata *self,
                              ClassLayoutFlags layoutFlags,
@@ -3108,11 +3093,6 @@ _swift_initClassMetadataImpl(ClassMetadata *self,
     (void)unused;
     setUpObjCRuntimeGetImageNameFromClass();
   }, nullptr);
-
-  // Temporary workaround until objc_loadClassref is in the SDK.
-  static auto objc_loadClassref =
-    (Class (*)(void *))
-    dlsym(RTLD_NEXT, "objc_loadClassref");
 #endif
 
   // Copy field offsets, generic arguments and (if necessary) vtable entries
@@ -3149,10 +3129,8 @@ _swift_initClassMetadataImpl(ClassMetadata *self,
     // The compiler enforces that @objc methods in extensions of classes
     // with resilient ancestry have the correct availability, so it should
     // be safe to ignore the stub in this case.
-    if (stub != nullptr &&
-        objc_loadClassref != nullptr &&
-        &_objc_realizeClassFromSwift != nullptr) {
-      _objc_realizeClassFromSwift((Class) self, const_cast<void *>(stub));
+    if (stub != nullptr && SWIFT_RUNTIME_WEAK_CHECK(_objc_realizeClassFromSwift)) {
+      SWIFT_RUNTIME_WEAK_USE(_objc_realizeClassFromSwift((Class) self, const_cast<void *>(stub)));
     } else {
       swift_instantiateObjCClass(self);
     }
@@ -3164,8 +3142,6 @@ _swift_initClassMetadataImpl(ClassMetadata *self,
   return MetadataDependency();
 }
 
-#pragma clang diagnostic pop
-
 void swift::swift_initClassMetadata(ClassMetadata *self,
                                     ClassLayoutFlags layoutFlags,
                                     size_t numFields,
@@ -3189,20 +3165,14 @@ swift::swift_initClassMetadata2(ClassMetadata *self,
 
 #if SWIFT_OBJC_INTEROP
 
-// Suppress diagnostic about the availability of _objc_realizeClassFromSwift.
-// We test availability with a nullptr check, but the compiler doesn't see that.
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunguarded-availability-new"
-
-
 static SWIFT_CC(swift) MetadataDependency
 _swift_updateClassMetadataImpl(ClassMetadata *self,
                                ClassLayoutFlags layoutFlags,
                                size_t numFields,
                                const TypeLayout * const *fieldTypes,
                                size_t *fieldOffsets,
                                bool allowDependency) {
-  bool requiresUpdate = (&_objc_realizeClassFromSwift != nullptr);
+  bool requiresUpdate = SWIFT_RUNTIME_WEAK_CHECK(_objc_realizeClassFromSwift);
 
   // If we're on a newer runtime, we're going to be initializing the
   // field offset vector. Realize the superclass metadata first, even
@@ -3250,7 +3220,7 @@ _swift_updateClassMetadataImpl(ClassMetadata *self,
     initObjCClass(self, numFields, fieldTypes, fieldOffsets);
 
     // See remark above about how this slides field offset globals.
-    _objc_realizeClassFromSwift((Class)self, (Class)self);
+    SWIFT_RUNTIME_WEAK_USE(_objc_realizeClassFromSwift((Class)self, (Class)self));
   }
 
   return MetadataDependency();
@@ -3277,7 +3247,6 @@ swift::swift_updateClassMetadata2(ClassMetadata *self,
                                         /*allowDependency*/ true);
 }
 
-#pragma clang diagnostic pop
 #endif
 
 #ifndef NDEBUG

stdlib/public/runtime/MetadataLookup.cpp

@@ -1959,23 +1959,9 @@ getObjCClassByMangledName(const char * _Nonnull typeName,
 
 __attribute__((constructor))
 static void installGetClassHook() {
-  // FIXME: delete this #if and dlsym once we don't
-  // need to build with older libobjc headers
-#if !OBJC_GETCLASSHOOK_DEFINED
-  using objc_hook_getClass =  BOOL(*)(const char * _Nonnull name,
-                                      Class _Nullable * _Nonnull outClass);
-  auto objc_setHook_getClass =
-    (void(*)(objc_hook_getClass _Nonnull,
-             objc_hook_getClass _Nullable * _Nonnull))
-    dlsym(RTLD_DEFAULT, "objc_setHook_getClass");
-#endif
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunguarded-availability"
-  if (&objc_setHook_getClass) {
-    objc_setHook_getClass(getObjCClassByMangledName, &OldGetClassHook);
+  if (SWIFT_RUNTIME_WEAK_CHECK(objc_setHook_getClass)) {
+    SWIFT_RUNTIME_WEAK_USE(objc_setHook_getClass(getObjCClassByMangledName, &OldGetClassHook));
   }
-#pragma clang diagnostic pop
 }
 
 #endif

stdlib/public/stubs/Availability.mm

@@ -21,21 +21,19 @@
 #include "swift/Runtime/Debug.h"
 #include <TargetConditionals.h>
 #include "../SwiftShims/FoundationShims.h"
-#include <dlfcn.h>
 
 struct os_system_version_s {
     unsigned int major;
     unsigned int minor;
     unsigned int patch;
 };
 
+// This is in libSystem, so it's OK to refer to it directly here
+extern "C" int os_system_version_get_current_version(struct os_system_version_s * _Nonnull) SWIFT_RUNTIME_WEAK_IMPORT;
+
 static os_system_version_s getOSVersion() {
-  auto lookup =
-    (int(*)(struct os_system_version_s * _Nonnull))
-    dlsym(RTLD_DEFAULT, "os_system_version_get_current_version");
-  
   struct os_system_version_s vers = { 0, 0, 0 };
-  lookup(&vers);
+  os_system_version_get_current_version(&vers);
   return vers;
 }
 

stdlib/public/stubs/FoundationHelpers.mm

@@ -35,10 +35,11 @@
 static CFHashCode(*_CFStringHashNSString)(id str);
 static CFTypeID(*_CFGetTypeID)(CFTypeRef obj);
 static CFTypeID _CFStringTypeID = 0;
-static bool(*dyld_is_objc_constant)(DyldObjCConstantKind kind,
-                                    const void *addr);
 static swift_once_t initializeBridgingFuncsOnce;
 
+extern "C" bool _dyld_is_objc_constant(DyldObjCConstantKind kind,
+                                       const void *addr) SWIFT_RUNTIME_WEAK_IMPORT;
+
 static void _initializeBridgingFunctionsImpl(void *ctxt) {
   auto getStringTypeID =
     (CFTypeID(*)(void))
@@ -52,11 +53,6 @@ static void _initializeBridgingFunctionsImpl(void *ctxt) {
   _CFStringHashCString = (CFHashCode(*)(const uint8_t *, CFIndex))dlsym(
                                                    RTLD_DEFAULT,
                                                    "CFStringHashCString");
-  if (dlsym(RTLD_NEXT, "objc_debug_tag60_permutations") /* tagged constant strings available */) {
-  dyld_is_objc_constant = (bool(*)(DyldObjCConstantKind, const void *))dlsym(
-                                                   RTLD_NEXT,
-                                                   "_dyld_is_objc_constant");
-  }
 }
 
 static inline void initializeBridgingFunctions() {
@@ -112,9 +108,8 @@ typedef __swift_uint8_t (*getCStringImplPtr)(id,
 
 __swift_uint8_t
 _swift_stdlib_dyld_is_objc_constant_string(const void *addr) {
-  initializeBridgingFunctions();
-  if (!dyld_is_objc_constant) return false;
-  return dyld_is_objc_constant(dyld_objc_string_kind, addr) ? 1 : 0;
+  return (SWIFT_RUNTIME_WEAK_CHECK(_dyld_is_objc_constant)
+          && SWIFT_RUNTIME_WEAK_USE(_dyld_is_objc_constant(dyld_objc_string_kind, addr))) ? 1 : 0;
 }
 
 #endif