Snapshot current runtime investigation

Author: DjDeveloperr

NativeScript/ffi/CFunction.mm

@@ -1,17 +1,187 @@
 #include "CFunction.h"
+#include <dispatch/dispatch.h>
+#include <cstring>
+#include <vector>
+#include "Block.h"
 #include "ClassMember.h"
+#include "Interop.h"
 #include "ObjCBridge.h"
 #include "SignatureDispatch.h"
 #include "ffi/NativeScriptException.h"
 #include "ffi/Tasks.h"
-#include <cstring>
-#include <vector>
 #ifdef ENABLE_JS_RUNTIME
 #include "jsr.h"
 #endif
 
 namespace nativescript {
 
+namespace {
+
+inline bool unwrapCompatNativeHandleForCFunction(napi_env env, napi_value value, void** out) {
+  if (value == nullptr || out == nullptr) {
+    return false;
+  }
+
+  if (Pointer::isInstance(env, value)) {
+    Pointer* ptr = Pointer::unwrap(env, value);
+    *out = ptr != nullptr ? ptr->data : nullptr;
+    return ptr != nullptr;
+  }
+
+  if (Reference::isInstance(env, value)) {
+    Reference* ref = Reference::unwrap(env, value);
+    *out = ref != nullptr ? ref->data : nullptr;
+    return ref != nullptr;
+  }
+
+  napi_valuetype valueType = napi_undefined;
+  if (napi_typeof(env, value, &valueType) != napi_ok) {
+    return false;
+  }
+
+  if (valueType == napi_bigint) {
+    uint64_t raw = 0;
+    bool lossless = false;
+    if (napi_get_value_bigint_uint64(env, value, &raw, &lossless) != napi_ok) {
+      return false;
+    }
+    *out = reinterpret_cast<void*>(static_cast<uintptr_t>(raw));
+    return true;
+  }
+
+  if (valueType == napi_external) {
+    return napi_get_value_external(env, value, out) == napi_ok;
+  }
+
+  if (valueType != napi_object && valueType != napi_function) {
+    return false;
+  }
+
+  bool hasNativePointer = false;
+  if (napi_has_named_property(env, value, "__ns_native_ptr", &hasNativePointer) == napi_ok &&
+      hasNativePointer) {
+    napi_value nativePointerValue = nullptr;
+    if (napi_get_named_property(env, value, "__ns_native_ptr", &nativePointerValue) == napi_ok &&
+        napi_get_value_external(env, nativePointerValue, out) == napi_ok && *out != nullptr) {
+      return true;
+    }
+  }
+
+  return napi_unwrap(env, value, out) == napi_ok && *out != nullptr;
+}
+
+inline napi_value createCompatDispatchQueueWrapperForCFunction(napi_env env,
+                                                               dispatch_queue_t queue) {
+  if (queue == nullptr) {
+    napi_value nullValue = nullptr;
+    napi_get_null(env, &nullValue);
+    return nullValue;
+  }
+
+  return Pointer::create(env, reinterpret_cast<void*>(queue));
+}
+
+inline napi_value tryCallCompatLibdispatchFunction(napi_env env, napi_callback_info cbinfo,
+                                                   const char* functionName) {
+  if (strcmp(functionName, "dispatch_get_global_queue") == 0) {
+    size_t argc = 2;
+    napi_value argv[2] = {nullptr, nullptr};
+    napi_get_cb_info(env, cbinfo, &argc, argv, nullptr, nullptr);
+
+    int64_t identifier = 0;
+    if (argc > 0) {
+      napi_valuetype identifierType = napi_undefined;
+      if (napi_typeof(env, argv[0], &identifierType) == napi_ok && identifierType == napi_bigint) {
+        bool lossless = false;
+        if (napi_get_value_bigint_int64(env, argv[0], &identifier, &lossless) != napi_ok) {
+          napi_throw_type_error(env, nullptr,
+                                "dispatch_get_global_queue expects a numeric identifier.");
+          return nullptr;
+        }
+      } else {
+        napi_value coercedIdentifier = nullptr;
+        if (napi_coerce_to_number(env, argv[0], &coercedIdentifier) != napi_ok ||
+            napi_get_value_int64(env, coercedIdentifier, &identifier) != napi_ok) {
+          napi_throw_type_error(env, nullptr,
+                                "dispatch_get_global_queue expects a numeric identifier.");
+          return nullptr;
+        }
+      }
+    }
+
+    uint64_t flags = 0;
+    if (argc > 1) {
+      napi_valuetype flagsType = napi_undefined;
+      if (napi_typeof(env, argv[1], &flagsType) == napi_ok && flagsType == napi_bigint) {
+        bool lossless = false;
+        if (napi_get_value_bigint_uint64(env, argv[1], &flags, &lossless) != napi_ok) {
+          napi_throw_type_error(env, nullptr, "dispatch_get_global_queue expects numeric flags.");
+          return nullptr;
+        }
+      } else {
+        napi_value coercedFlags = nullptr;
+        int64_t signedFlags = 0;
+        if (napi_coerce_to_number(env, argv[1], &coercedFlags) != napi_ok ||
+            napi_get_value_int64(env, coercedFlags, &signedFlags) != napi_ok) {
+          napi_throw_type_error(env, nullptr, "dispatch_get_global_queue expects numeric flags.");
+          return nullptr;
+        }
+        flags = static_cast<uint64_t>(signedFlags);
+      }
+    }
+
+    return createCompatDispatchQueueWrapperForCFunction(
+        env, dispatch_get_global_queue(identifier, flags));
+  }
+
+  if (strcmp(functionName, "dispatch_get_current_queue") == 0) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+    return createCompatDispatchQueueWrapperForCFunction(env, dispatch_get_current_queue());
+#pragma clang diagnostic pop
+  }
+
+  if (strcmp(functionName, "dispatch_async") == 0) {
+    size_t argc = 2;
+    napi_value argv[2] = {nullptr, nullptr};
+    napi_get_cb_info(env, cbinfo, &argc, argv, nullptr, nullptr);
+
+    if (argc < 2) {
+      napi_throw_type_error(env, nullptr, "dispatch_async expects a queue and callback.");
+      return nullptr;
+    }
+
+    void* queueHandle = nullptr;
+    if (!unwrapCompatNativeHandleForCFunction(env, argv[0], &queueHandle) ||
+        queueHandle == nullptr) {
+      napi_throw_type_error(env, nullptr, "dispatch_async expects a native queue handle.");
+      return nullptr;
+    }
+
+    napi_valuetype callbackType = napi_undefined;
+    if (napi_typeof(env, argv[1], &callbackType) != napi_ok || callbackType != napi_function) {
+      napi_throw_type_error(env, nullptr, "dispatch_async expects a function callback.");
+      return nullptr;
+    }
+
+    auto closure = new Closure(std::string("v"), true);
+    closure->env = env;
+    id block = registerBlock(env, closure, argv[1]);
+    dispatch_block_t dispatchBlock = (dispatch_block_t)block;
+
+    dispatch_async(reinterpret_cast<dispatch_queue_t>(queueHandle), dispatchBlock);
+    [block release];
+
+    napi_value undefinedValue = nullptr;
+    napi_get_undefined(env, &undefinedValue);
+    return undefinedValue;
+  }
+
+  return nullptr;
+}
+
+}  // namespace
+
 inline void ensureCFunctionDispatchLookup(CFunction* function, Cif* cif) {
   if (function == nullptr || cif == nullptr || cif->signatureHash == 0) {
     if (function != nullptr) {
@@ -34,8 +204,7 @@ inline void ensureCFunctionDispatchLookup(CFunction* function, Cif* cif) {
       cif->signatureHash, SignatureCallKind::CFunction, function->dispatchFlags);
   function->preparedInvoker =
       reinterpret_cast<void*>(lookupCFunctionPreparedInvoker(function->dispatchId));
-  function->napiInvoker =
-      reinterpret_cast<void*>(lookupCFunctionNapiInvoker(function->dispatchId));
+  function->napiInvoker = reinterpret_cast<void*>(lookupCFunctionNapiInvoker(function->dispatchId));
   function->dispatchLookupCached = true;
 }
 
@@ -90,15 +259,20 @@ inline void ensureCFunctionDispatchLookup(CFunction* function, Cif* cif) {
 
   auto name = bridgeState->metadata->getString(offset);
 
+  if (strcmp(name, "dispatch_async") == 0 || strcmp(name, "dispatch_get_current_queue") == 0 ||
+      strcmp(name, "dispatch_get_global_queue") == 0) {
+    return tryCallCompatLibdispatchFunction(env, cbinfo, name);
+  }
+
   auto func = bridgeState->getCFunction(env, offset);
 
   auto cif = func->cif;
   ensureCFunctionDispatchLookup(func, cif);
   auto preparedInvoker = reinterpret_cast<CFunctionPreparedInvoker>(func->preparedInvoker);
   auto napiInvoker = reinterpret_cast<CFunctionNapiInvoker>(func->napiInvoker);
 
-  MDFunctionFlag functionFlags = bridgeState->metadata->getFunctionFlag(
-      offset + sizeof(MDSectionOffset) * 2);
+  MDFunctionFlag functionFlags =
+      bridgeState->metadata->getFunctionFlag(offset + sizeof(MDSectionOffset) * 2);
 
   const napi_value* invocationArgs = nullptr;
   std::vector<napi_value> dynamicArgs;
@@ -139,7 +313,7 @@ inline void ensureCFunctionDispatchLookup(CFunction* function, Cif* cif) {
   const bool isMainEntrypoint =
       strcmp(name, "UIApplicationMain") == 0 || strcmp(name, "NSApplicationMain") == 0;
 
-  if (napiInvoker != nullptr && !isMainEntrypoint) {
+  if (napiInvoker != nullptr && !cif->skipGeneratedNapiDispatch && !isMainEntrypoint) {
     @try {
       if (!napiInvoker(env, cif, func->fnptr, invocationArgs, cif->rvalue)) {
         return nullptr;

NativeScript/ffi/Cif.h

@@ -20,6 +20,7 @@ class Cif {
   size_t rvalueLength;
   bool isVariadic = false;
   uint64_t signatureHash = 0;
+  bool skipGeneratedNapiDispatch = false;
 
   void* rvalue;
   void** avalues;

NativeScript/ffi/Cif.mm

@@ -18,8 +18,7 @@
 constexpr uint64_t kFNV64OffsetBasis = 14695981039346656037ull;
 constexpr uint64_t kFNV64Prime = 1099511628211ull;
 
-uint64_t hashBytesFnv1a(const void* data, size_t size,
-                        uint64_t seed = kFNV64OffsetBasis) {
+uint64_t hashBytesFnv1a(const void* data, size_t size, uint64_t seed = kFNV64OffsetBasis) {
   const auto* bytes = static_cast<const uint8_t*>(data);
   uint64_t hash = seed;
   for (size_t i = 0; i < size; i++) {
@@ -53,24 +52,52 @@ void appendIntegralToHash(uint64_t* hash, T value) {
   }
 }
 
-bool appendMetadataSignatureHash(MDMetadataReader* reader,
-                                 MDSectionOffset signatureOffset,
+bool appendMetadataSignatureHash(MDMetadataReader* reader, MDSectionOffset signatureOffset,
                                  std::unordered_set<MDSectionOffset>* activeSignatures,
                                  uint64_t* hash);
 
+inline bool typeRequiresSlowGeneratedNapiDispatch(const std::shared_ptr<TypeConv>& type) {
+  if (type == nullptr) {
+    return false;
+  }
+
+  switch (type->kind) {
+    case mdTypeUChar:
+    case mdTypeUInt8:
+      return true;
+    default:
+      return false;
+  }
+}
+
+inline void updateGeneratedNapiDispatchCompatibility(Cif* cif) {
+  if (cif == nullptr) {
+    return;
+  }
+
+  cif->skipGeneratedNapiDispatch = typeRequiresSlowGeneratedNapiDispatch(cif->returnType);
+  if (cif->skipGeneratedNapiDispatch) {
+    return;
+  }
+
+  for (const auto& argType : cif->argTypes) {
+    if (typeRequiresSlowGeneratedNapiDispatch(argType)) {
+      cif->skipGeneratedNapiDispatch = true;
+      return;
+    }
+  }
+}
+
 bool appendMetadataTypeHash(MDMetadataReader* reader, MDSectionOffset* offset,
-                            std::unordered_set<MDSectionOffset>* activeSignatures,
-                            uint64_t* hash) {
-  if (reader == nullptr || offset == nullptr || hash == nullptr ||
-      activeSignatures == nullptr) {
+                            std::unordered_set<MDSectionOffset>* activeSignatures, uint64_t* hash) {
+  if (reader == nullptr || offset == nullptr || hash == nullptr || activeSignatures == nullptr) {
     return false;
   }
 
   const MDTypeKind kindWithFlags = reader->getTypeKind(*offset);
   *offset += sizeof(MDTypeKind);
   const MDTypeKind rawKind =
-      static_cast<MDTypeKind>((kindWithFlags & ~mdTypeFlagNext) &
-                              ~mdTypeFlagVariadic);
+      static_cast<MDTypeKind>((kindWithFlags & ~mdTypeFlagNext) & ~mdTypeFlagVariadic);
 
   appendIntegralToHash<uint8_t>(hash, 0xB0);
   const MDTypeKind canonicalKind = canonicalizeSignatureTypeKind(rawKind);
@@ -130,10 +157,8 @@ bool appendMetadataTypeHash(MDMetadataReader* reader, MDSectionOffset* offset,
       const auto nestedSignatureOffset = reader->getOffset(*offset);
       *offset += sizeof(MDSectionOffset);
       if (nestedSignatureOffset != MD_SECTION_OFFSET_NULL) {
-        const auto nestedAbsoluteOffset =
-            reader->signaturesOffset + nestedSignatureOffset;
-        if (!appendMetadataSignatureHash(reader, nestedAbsoluteOffset,
-                                         activeSignatures, hash)) {
+        const auto nestedAbsoluteOffset = reader->signaturesOffset + nestedSignatureOffset;
+        if (!appendMetadataSignatureHash(reader, nestedAbsoluteOffset, activeSignatures, hash)) {
           return false;
         }
       }
@@ -148,8 +173,7 @@ bool appendMetadataTypeHash(MDMetadataReader* reader, MDSectionOffset* offset,
   return true;
 }
 
-bool appendMetadataSignatureHash(MDMetadataReader* reader,
-                                 MDSectionOffset signatureOffset,
+bool appendMetadataSignatureHash(MDMetadataReader* reader, MDSectionOffset signatureOffset,
                                  std::unordered_set<MDSectionOffset>* activeSignatures,
                                  uint64_t* hash) {
   if (reader == nullptr || hash == nullptr || activeSignatures == nullptr) {
@@ -301,6 +325,8 @@ bool appendMetadataSignatureHash(MDMetadataReader* reader,
     this->avalues[i] = malloc(cif.arg_types[i + skippedArgs]->size);
     this->avaluesAllocCount++;
   }
+
+  updateGeneratedNapiDispatchCompatibility(this);
 }
 
 Cif::Cif(napi_env env, Method method) {
@@ -359,6 +385,8 @@ bool appendMetadataSignatureHash(MDMetadataReader* reader,
     this->avalues[i] = malloc(cif.arg_types[i + 2]->size);
     this->avaluesAllocCount++;
   }
+
+  updateGeneratedNapiDispatchCompatibility(this);
 }
 
 Cif::Cif(napi_env env, MDMetadataReader* reader, MDSectionOffset offset, bool isMethod,
@@ -442,6 +470,8 @@ bool appendMetadataSignatureHash(MDMetadataReader* reader,
       signatureHash = canonicalSignatureHash;
     }
   }
+
+  updateGeneratedNapiDispatchCompatibility(this);
 }
 
 Cif::~Cif() {

NativeScript/ffi/Class.mm

@@ -304,14 +304,15 @@ void setupObjCClassDecorator(napi_env env) {
     if (argc == 1 && argv[0] != nullptr) {
       void* rawPointer = nullptr;
       if (tryGetInteropPointerArg(env, argv[0], &rawPointer) && rawPointer != nullptr) {
+        if (napi_value cached = bridgeState->getCachedHandleObject(env, rawPointer);
+            cached != nullptr) {
+          return cached;
+        }
+
         object = (id)rawPointer;
-        napi_value constructor = nullptr;
-        if (napi_get_named_property(env, jsThis, "constructor", &constructor) == napi_ok &&
-            constructor != nullptr) {
-          napi_value existing = bridgeState->getObject(env, object, constructor, kUnownedObject);
-          if (existing != nullptr) {
-            return existing;
-          }
+        if (napi_value existing = bridgeState->findCachedObjectWrapper(env, object);
+            existing != nullptr) {
+          return existing;
         }
 
         jsThis = bridgeState->proxyNativeObject(env, jsThis, object);