feat(jsc): Update to newer version of JSC and add support for host objects in JSC

This only supports x86_64 and arm64_v8a abis.

Author: ammarahm-ed

test-app/runtime/src/main/cpp/napi/jsc/JavaScriptCore/APICallbackFunction.h

@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2013-2020 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#ifndef APICallbackFunction_h
+#define APICallbackFunction_h
+
+#include "APICast.h"
+#include "Error.h"
+#include "JSCallbackConstructor.h"
+#include "JSLock.h"
+#include <wtf/Vector.h>
+
+namespace JSC {
+
+struct APICallbackFunction {
+    template <typename T> static EncodedJSValue callImpl(JSGlobalObject*, CallFrame*);
+    template <typename T> static EncodedJSValue constructImpl(JSGlobalObject*, CallFrame*);
+};
+
+template <typename T>
+EncodedJSValue APICallbackFunction::callImpl(JSGlobalObject* globalObject, CallFrame* callFrame)
+{
+    VM& vm = getVM(globalObject);
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    JSContextRef execRef = toRef(globalObject);
+    JSObjectRef functionRef = toRef(callFrame->jsCallee());
+    JSObjectRef thisObjRef = toRef(jsCast<JSObject*>(callFrame->thisValue().toThis(globalObject, ECMAMode::sloppy())));
+
+    int argumentCount = static_cast<int>(callFrame->argumentCount());
+    Vector<JSValueRef, 16> arguments(argumentCount, [&](size_t i) {
+        return toRef(globalObject, callFrame->uncheckedArgument(i));
+    });
+
+    JSValueRef exception = nullptr;
+    JSValueRef result;
+    {
+        JSLock::DropAllLocks dropAllLocks(globalObject);
+        result = jsCast<T*>(toJS(functionRef))->functionCallback()(execRef, functionRef, thisObjRef, argumentCount, arguments.span().data(), &exception);
+    }
+    if (exception) {
+        throwException(globalObject, scope, toJS(globalObject, exception));
+        return JSValue::encode(jsUndefined());
+    }
+
+    // result must be a valid JSValue.
+    if (!result)
+        return JSValue::encode(jsUndefined());
+
+    return JSValue::encode(toJS(globalObject, result));
+}
+
+template <typename T>
+EncodedJSValue APICallbackFunction::constructImpl(JSGlobalObject* globalObject, CallFrame* callFrame)
+{
+    VM& vm = getVM(globalObject);
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    JSValue callee = callFrame->jsCallee();
+    T* constructor = jsCast<T*>(callFrame->jsCallee());
+    JSContextRef ctx = toRef(globalObject);
+    JSObjectRef constructorRef = toRef(constructor);
+
+    JSObjectCallAsConstructorCallback callback = constructor->constructCallback();
+    if (callback) {
+        JSValue prototype;
+        JSValue newTarget = callFrame->newTarget();
+        // If we are doing a derived class construction get the .prototype property off the new target first so we behave closer to normal JS.
+        if (newTarget != constructor) {
+            prototype = newTarget.get(globalObject, vm.propertyNames->prototype);
+            RETURN_IF_EXCEPTION(scope, { });
+        }
+
+        size_t argumentCount = callFrame->argumentCount();
+        Vector<JSValueRef, 16> arguments(argumentCount, [&](size_t i) {
+            return toRef(globalObject, callFrame->uncheckedArgument(i));
+        });
+
+        JSValueRef exception = nullptr;
+        JSObjectRef result;
+        {
+            JSLock::DropAllLocks dropAllLocks(globalObject);
+            result = callback(ctx, constructorRef, argumentCount, arguments.span().data(), &exception);
+        }
+
+        if (exception) {
+            throwException(globalObject, scope, toJS(globalObject, exception));
+            return JSValue::encode(jsUndefined());
+        }
+        // result must be a valid JSValue.
+        if (!result)
+            return throwVMTypeError(globalObject, scope);
+
+        JSObject* newObject = toJS(result);
+        // This won't trigger proxy traps on newObject's prototype handler but that's probably desirable here anyway.
+        if (newTarget != constructor && newObject->getPrototypeDirect() == constructor->get(globalObject, vm.propertyNames->prototype)) {
+            RETURN_IF_EXCEPTION(scope, { });
+            newObject->setPrototype(vm, globalObject, prototype);
+            RETURN_IF_EXCEPTION(scope, { });
+        }
+
+        return JSValue::encode(newObject);
+    }
+    
+    return JSValue::encode(toJS(JSObjectMake(ctx, jsCast<JSCallbackConstructor*>(callee)->classRef(), nullptr)));
+}
+
+} // namespace JSC
+
+#endif // APICallbackFunction_h

…api/jsc/include/JavaScriptCore/APICast.h …in/cpp/napi/jsc/JavaScriptCore/APICast.htest-app/runtime/src/main/cpp/napi/jsc/include/JavaScriptCore/APICast.h renamed to test-app/runtime/src/main/cpp/napi/jsc/JavaScriptCore/APICast.h test-app/runtime/src/main/cpp/napi/jsc/include/JavaScriptCore/APICast.h renamed to test-app/runtime/src/main/cpp/napi/jsc/JavaScriptCore/APICast.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2006-2019 Apple Inc.  All rights reserved.
+ * Copyright (C) 2006-2022 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -23,17 +23,22 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-#ifndef APICast_h
-#define APICast_h
+#pragma once
 
+#include <wtf/Compiler.h>
+
+WTF_ALLOW_UNSAFE_BUFFER_USAGE_BEGIN
+
+#include "HeapCellInlines.h"
+#include "Integrity.h"
 #include "JSAPIValueWrapper.h"
 #include "JSCJSValue.h"
 #include "JSCJSValueInlines.h"
-#include "JSGlobalObject.h"
-#include "HeapCellInlines.h"
+
+WTF_ALLOW_UNSAFE_BUFFER_USAGE_END
 
 namespace JSC {
-    class ExecState;
+    class CallFrame;
     class PropertyNameArray;
     class VM;
     class JSObject;
@@ -49,26 +54,26 @@ typedef struct OpaqueJSValue* JSObjectRef;
 
 /* Opaque typing convenience methods */
 
-inline JSC::ExecState* toJS(JSContextRef c)
+inline JSC::JSGlobalObject* toJS(JSContextRef context)
 {
-    ASSERT(c);
-    return reinterpret_cast<JSC::ExecState*>(const_cast<OpaqueJSContext*>(c));
+    ASSERT(context);
+    return JSC::Integrity::audit(reinterpret_cast<JSC::JSGlobalObject*>(const_cast<OpaqueJSContext*>(context)));
 }
 
-inline JSC::ExecState* toJS(JSGlobalContextRef c)
+inline JSC::JSGlobalObject* toJS(JSGlobalContextRef context)
 {
-    ASSERT(c);
-    return reinterpret_cast<JSC::ExecState*>(c);
+    ASSERT(context);
+    return JSC::Integrity::audit(reinterpret_cast<JSC::JSGlobalObject*>(context));
 }
 
 inline JSC::JSGlobalObject* toJSGlobalObject(JSGlobalContextRef context)
 {
-    return toJS(context)->lexicalGlobalObject();
+    return toJS(context);
 }
 
-inline JSC::JSValue toJS(JSC::ExecState* exec, JSValueRef v)
+inline JSC::JSValue toJS(JSC::JSGlobalObject* globalObject, JSValueRef v)
 {
-    ASSERT_UNUSED(exec, exec);
+    ASSERT_UNUSED(globalObject, globalObject);
 #if !CPU(ADDRESS64)
     JSC::JSCell* jsCell = reinterpret_cast<JSC::JSCell*>(const_cast<OpaqueJSValue*>(v));
     if (!jsCell)
@@ -79,42 +84,53 @@ inline JSC::JSValue toJS(JSC::ExecState* exec, JSValueRef v)
     else
         result = jsCell;
 #else
-    JSC::JSValue result = bitwise_cast<JSC::JSValue>(v);
+    JSC::JSValue result = std::bit_cast<JSC::JSValue>(v);
 #endif
     if (!result)
         return JSC::jsNull();
-    if (result.isCell())
-        RELEASE_ASSERT(result.asCell()->methodTable(exec->vm()));
+    if (result.isCell()) {
+        JSC::Integrity::audit(result.asCell());
+        RELEASE_ASSERT(result.asCell()->methodTable());
+    }
     return result;
 }
 
-inline JSC::JSValue toJSForGC(JSC::ExecState* exec, JSValueRef v)
+#if CPU(ADDRESS64)
+inline JSC::JSValue toJS(JSValueRef value)
+{
+    return JSC::Integrity::audit(std::bit_cast<JSC::JSValue>(value));
+}
+#endif
+
+inline JSC::JSValue toJSForGC(JSC::JSGlobalObject* globalObject, JSValueRef v)
 {
-    ASSERT_UNUSED(exec, exec);
+    ASSERT_UNUSED(globalObject, globalObject);
 #if !CPU(ADDRESS64)
     JSC::JSCell* jsCell = reinterpret_cast<JSC::JSCell*>(const_cast<OpaqueJSValue*>(v));
     if (!jsCell)
         return JSC::JSValue();
     JSC::JSValue result = jsCell;
 #else
-    JSC::JSValue result = bitwise_cast<JSC::JSValue>(v);
+    JSC::JSValue result = std::bit_cast<JSC::JSValue>(v);
 #endif
-    if (result && result.isCell())
-        RELEASE_ASSERT(result.asCell()->methodTable(exec->vm()));
+    if (result && result.isCell()) {
+        JSC::Integrity::audit(result.asCell());
+        RELEASE_ASSERT(result.asCell()->methodTable());
+    }
     return result;
 }
 
 // Used in JSObjectGetPrivate as that may be called during finalization
 inline JSC::JSObject* uncheckedToJS(JSObjectRef o)
 {
-    return reinterpret_cast<JSC::JSObject*>(o);
+    return JSC::Integrity::audit(reinterpret_cast<JSC::JSObject*>(o));
 }
 
 inline JSC::JSObject* toJS(JSObjectRef o)
 {
     JSC::JSObject* object = uncheckedToJS(o);
     if (object)
-        RELEASE_ASSERT(object->methodTable(object->vm()));
+        RELEASE_ASSERT(object->methodTable());
     return object;
 }
 
@@ -125,7 +141,7 @@ inline JSC::PropertyNameArray* toJS(JSPropertyNameAccumulatorRef a)
 
 inline JSC::VM* toJS(JSContextGroupRef g)
 {
-    return reinterpret_cast<JSC::VM*>(const_cast<OpaqueJSContextGroup*>(g));
+    return JSC::Integrity::audit(reinterpret_cast<JSC::VM*>(const_cast<OpaqueJSContextGroup*>(g)));
 }
 
 inline JSValueRef toRef(JSC::VM& vm, JSC::JSValue v)
@@ -139,34 +155,40 @@ inline JSValueRef toRef(JSC::VM& vm, JSC::JSValue v)
     return reinterpret_cast<JSValueRef>(v.asCell());
 #else
     UNUSED_PARAM(vm);
-    return bitwise_cast<JSValueRef>(v);
+    return std::bit_cast<JSValueRef>(JSC::Integrity::audit(v));
 #endif
 }
 
-inline JSValueRef toRef(JSC::ExecState* exec, JSC::JSValue v)
+inline JSValueRef toRef(JSC::JSGlobalObject* globalObject, JSC::JSValue v)
 {
-    return toRef(exec->vm(), v);
+    return toRef(getVM(globalObject), v);
 }
 
+#if CPU(ADDRESS64)
+inline JSValueRef toRefWithoutGlobalObject(JSC::JSValue v)
+{
+    return std::bit_cast<JSValueRef>(JSC::Integrity::audit(v));
+}
+#endif
+
 inline JSObjectRef toRef(JSC::JSObject* o)
 {
-    return reinterpret_cast<JSObjectRef>(o);
+    return reinterpret_cast<JSObjectRef>(JSC::Integrity::audit(o));
 }
 
 inline JSObjectRef toRef(const JSC::JSObject* o)
 {
-    return reinterpret_cast<JSObjectRef>(const_cast<JSC::JSObject*>(o));
+    return reinterpret_cast<JSObjectRef>(JSC::Integrity::audit(const_cast<JSC::JSObject*>(o)));
 }
 
-inline JSContextRef toRef(JSC::ExecState* e)
+inline JSContextRef toRef(JSC::JSGlobalObject* globalObject)
 {
-    return reinterpret_cast<JSContextRef>(e);
+    return reinterpret_cast<JSContextRef>(JSC::Integrity::audit(globalObject));
 }
 
-inline JSGlobalContextRef toGlobalRef(JSC::ExecState* e)
+inline JSGlobalContextRef toGlobalRef(JSC::JSGlobalObject* globalObject)
 {
-    ASSERT(e == e->lexicalGlobalObject()->globalExec());
-    return reinterpret_cast<JSGlobalContextRef>(e);
+    return reinterpret_cast<JSGlobalContextRef>(JSC::Integrity::audit(globalObject));
 }
 
 inline JSPropertyNameAccumulatorRef toRef(JSC::PropertyNameArray* l)
@@ -176,7 +198,5 @@ inline JSPropertyNameAccumulatorRef toRef(JSC::PropertyNameArray* l)
 
 inline JSContextGroupRef toRef(JSC::VM* g)
 {
-    return reinterpret_cast<JSContextGroupRef>(g);
+    return reinterpret_cast<JSContextGroupRef>(JSC::Integrity::audit(g));
 }
-
-#endif // APICast_h