Update Sources To JavaScriptCore-7611.3.10.1.3

Author: CuriousTommy

.gitignore

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013, 2016 Apple Inc. All rights reserved.
+ * 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
@@ -35,77 +35,96 @@
 namespace JSC {
 
 struct APICallbackFunction {
-
-template <typename T> static EncodedJSValue JSC_HOST_CALL call(ExecState*);
-template <typename T> static EncodedJSValue JSC_HOST_CALL construct(ExecState*);
-
+    template <typename T> static EncodedJSValue callImpl(JSGlobalObject*, CallFrame*);
+    template <typename T> static EncodedJSValue constructImpl(JSGlobalObject*, CallFrame*);
 };
 
 template <typename T>
-EncodedJSValue JSC_HOST_CALL APICallbackFunction::call(ExecState* exec)
+EncodedJSValue APICallbackFunction::callImpl(JSGlobalObject* globalObject, CallFrame* callFrame)
 {
-    VM& vm = exec->vm();
+    VM& vm = getVM(globalObject);
     auto scope = DECLARE_THROW_SCOPE(vm);
-    JSContextRef execRef = toRef(exec);
-    JSObjectRef functionRef = toRef(exec->jsCallee());
-    JSObjectRef thisObjRef = toRef(jsCast<JSObject*>(exec->thisValue().toThis(exec, NotStrictMode)));
+    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>(exec->argumentCount());
+    int argumentCount = static_cast<int>(callFrame->argumentCount());
     Vector<JSValueRef, 16> arguments;
     arguments.reserveInitialCapacity(argumentCount);
     for (int i = 0; i < argumentCount; i++)
-        arguments.uncheckedAppend(toRef(exec, exec->uncheckedArgument(i)));
+        arguments.uncheckedAppend(toRef(globalObject, callFrame->uncheckedArgument(i)));
 
-    JSValueRef exception = 0;
+    JSValueRef exception = nullptr;
     JSValueRef result;
     {
-        JSLock::DropAllLocks dropAllLocks(exec);
+        JSLock::DropAllLocks dropAllLocks(globalObject);
         result = jsCast<T*>(toJS(functionRef))->functionCallback()(execRef, functionRef, thisObjRef, argumentCount, arguments.data(), &exception);
     }
-    if (exception)
-        throwException(exec, scope, toJS(exec, 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(exec, result));
+    return JSValue::encode(toJS(globalObject, result));
 }
 
 template <typename T>
-EncodedJSValue JSC_HOST_CALL APICallbackFunction::construct(ExecState* exec)
+EncodedJSValue APICallbackFunction::constructImpl(JSGlobalObject* globalObject, CallFrame* callFrame)
 {
-    VM& vm = exec->vm();
+    VM& vm = getVM(globalObject);
     auto scope = DECLARE_THROW_SCOPE(vm);
-    JSObject* constructor = exec->jsCallee();
-    JSContextRef ctx = toRef(exec);
+    JSValue callee = callFrame->jsCallee();
+    T* constructor = jsCast<T*>(callFrame->jsCallee());
+    JSContextRef ctx = toRef(globalObject);
     JSObjectRef constructorRef = toRef(constructor);
 
-    JSObjectCallAsConstructorCallback callback = jsCast<T*>(constructor)->constructCallback();
+    JSObjectCallAsConstructorCallback callback = constructor->constructCallback();
     if (callback) {
-        size_t argumentCount = exec->argumentCount();
+        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;
         arguments.reserveInitialCapacity(argumentCount);
         for (size_t i = 0; i < argumentCount; ++i)
-            arguments.uncheckedAppend(toRef(exec, exec->uncheckedArgument(i)));
+            arguments.uncheckedAppend(toRef(globalObject, callFrame->uncheckedArgument(i)));
 
-        JSValueRef exception = 0;
+        JSValueRef exception = nullptr;
         JSObjectRef result;
         {
-            JSLock::DropAllLocks dropAllLocks(exec);
+            JSLock::DropAllLocks dropAllLocks(globalObject);
             result = callback(ctx, constructorRef, argumentCount, arguments.data(), &exception);
         }
+
         if (exception) {
-            throwException(exec, scope, toJS(exec, exception));
-            return JSValue::encode(toJS(exec, exception));
+            throwException(globalObject, scope, toJS(globalObject, exception));
+            return JSValue::encode(jsUndefined());
         }
         // result must be a valid JSValue.
         if (!result)
-            return throwVMTypeError(exec, scope);
-        return JSValue::encode(toJS(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(vm) == 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*>(constructor)->classRef(), 0)));
+    return JSValue::encode(toJS(JSObjectMake(ctx, jsCast<JSCallbackConstructor*>(callee)->classRef(), nullptr)));
 }
 
 } // namespace JSC

API/APICallbackFunction.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2006 Apple Inc.  All rights reserved.
+ * Copyright (C) 2006-2019 Apple Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -33,7 +33,7 @@
 #include "HeapCellInlines.h"
 
 namespace JSC {
-    class ExecState;
+    class CallFrame;
     class PropertyNameArray;
     class VM;
     class JSObject;
@@ -49,26 +49,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 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 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)
@@ -84,13 +84,20 @@ inline JSC::JSValue toJS(JSC::ExecState* exec, JSValueRef v)
     if (!result)
         return JSC::jsNull();
     if (result.isCell())
-        RELEASE_ASSERT(result.asCell()->methodTable(exec->vm()));
+        RELEASE_ASSERT(result.asCell()->methodTable(getVM(globalObject)));
     return result;
 }
 
-inline JSC::JSValue toJSForGC(JSC::ExecState* exec, JSValueRef v)
+#if CPU(ADDRESS64)
+inline JSC::JSValue toJS(JSValueRef value)
 {
-    ASSERT_UNUSED(exec, exec);
+    return bitwise_cast<JSC::JSValue>(value);
+}
+#endif
+
+inline JSC::JSValue toJSForGC(JSC::JSGlobalObject* globalObject, JSValueRef v)
+{
+    ASSERT_UNUSED(globalObject, globalObject);
 #if !CPU(ADDRESS64)
     JSC::JSCell* jsCell = reinterpret_cast<JSC::JSCell*>(const_cast<OpaqueJSValue*>(v));
     if (!jsCell)
@@ -100,7 +107,7 @@ inline JSC::JSValue toJSForGC(JSC::ExecState* exec, JSValueRef v)
     JSC::JSValue result = bitwise_cast<JSC::JSValue>(v);
 #endif
     if (result && result.isCell())
-        RELEASE_ASSERT(result.asCell()->methodTable(exec->vm()));
+        RELEASE_ASSERT(result.asCell()->methodTable(getVM(globalObject)));
     return result;
 }
 
@@ -114,7 +121,7 @@ inline JSC::JSObject* toJS(JSObjectRef o)
 {
     JSC::JSObject* object = uncheckedToJS(o);
     if (object)
-        RELEASE_ASSERT(object->methodTable(*object->vm()));
+        RELEASE_ASSERT(object->methodTable(object->vm()));
     return object;
 }
 
@@ -143,11 +150,18 @@ inline JSValueRef toRef(JSC::VM& vm, JSC::JSValue 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 toRef(JSC::JSValue v)
+{
+    return bitwise_cast<JSValueRef>(v);
+}
+#endif
+
 inline JSObjectRef toRef(JSC::JSObject* o)
 {
     return reinterpret_cast<JSObjectRef>(o);
@@ -158,15 +172,14 @@ inline JSObjectRef toRef(const JSC::JSObject* o)
     return reinterpret_cast<JSObjectRef>(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>(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>(globalObject);
 }
 
 inline JSPropertyNameAccumulatorRef toRef(JSC::PropertyNameArray* l)

API/APICast.h

@@ -37,28 +37,30 @@ enum class ExceptionStatus {
     DidNotThrow
 };
 
-inline ExceptionStatus handleExceptionIfNeeded(JSC::CatchScope& scope, JSC::ExecState* exec, JSValueRef* returnedExceptionRef)
+inline ExceptionStatus handleExceptionIfNeeded(JSC::CatchScope& scope, JSContextRef ctx, JSValueRef* returnedExceptionRef)
 {
+    JSC::JSGlobalObject* globalObject = toJS(ctx);
     if (UNLIKELY(scope.exception())) {
         JSC::Exception* exception = scope.exception();
         if (returnedExceptionRef)
-            *returnedExceptionRef = toRef(exec, exception->value());
+            *returnedExceptionRef = toRef(globalObject, exception->value());
         scope.clearException();
 #if ENABLE(REMOTE_INSPECTOR)
-        scope.vm().vmEntryGlobalObject(exec)->inspectorController().reportAPIException(exec, exception);
+        globalObject->inspectorController().reportAPIException(globalObject, exception);
 #endif
         return ExceptionStatus::DidThrow;
     }
     return ExceptionStatus::DidNotThrow;
 }
 
-inline void setException(JSC::ExecState* exec, JSValueRef* returnedExceptionRef, JSC::JSValue exception)
+inline void setException(JSContextRef ctx, JSValueRef* returnedExceptionRef, JSC::JSValue exception)
 {
+    JSC::JSGlobalObject* globalObject = toJS(ctx);
     if (returnedExceptionRef)
-        *returnedExceptionRef = toRef(exec, exception);
+        *returnedExceptionRef = toRef(globalObject, exception);
 #if ENABLE(REMOTE_INSPECTOR)
-    JSC::VM& vm = exec->vm();
-    vm.vmEntryGlobalObject(exec)->inspectorController().reportAPIException(exec, JSC::Exception::create(vm, exception));
+    JSC::VM& vm = getVM(globalObject);
+    globalObject->inspectorController().reportAPIException(globalObject, JSC::Exception::create(vm, exception));
 #endif
 }
 

API/APIUtils.h

@@ -44,11 +44,19 @@ const GlobalObjectMethodTable JSAPIGlobalObject::s_globalObjectMethodTable = {
     nullptr, // moduleLoaderCreateImportMetaProperties
     nullptr, // moduleLoaderEvaluate
     nullptr, // promiseRejectionTracker
+    &reportUncaughtExceptionAtEventLoop,
+    &currentScriptExecutionOwner,
+    &scriptExecutionStatus,
     nullptr, // defaultLanguage
     nullptr, // compileStreaming
     nullptr, // instantiateStreaming
 };
 
+void JSAPIGlobalObject::reportUncaughtExceptionAtEventLoop(JSGlobalObject* globalObject, Exception* exception)
+{
+    Base::reportUncaughtExceptionAtEventLoop(globalObject, exception);
+}
+
 }
 
 #endif

API/JSAPIGlobalObject.cpp

@@ -31,13 +31,20 @@ OBJC_CLASS JSScript;
 
 namespace JSC {
 
-class JSAPIGlobalObject : public JSGlobalObject {
+class JSAPIGlobalObject final : public JSGlobalObject {
 public:
     using Base = JSGlobalObject;
 
     DECLARE_EXPORT_INFO;
     static const GlobalObjectMethodTable s_globalObjectMethodTable;
 
+    static constexpr bool needsDestruction = true;
+    template<typename CellType, SubspaceAccess mode>
+    static IsoSubspace* subspaceFor(VM& vm)
+    {
+        return vm.apiGlobalObjectSpace<mode>();
+    }
+
     static JSAPIGlobalObject* create(VM& vm, Structure* structure)
     {
         auto* object = new (NotNull, allocateCell<JSAPIGlobalObject>(vm.heap)) JSAPIGlobalObject(vm, structure);
@@ -47,16 +54,18 @@ class JSAPIGlobalObject : public JSGlobalObject {
 
     static Structure* createStructure(VM& vm, JSValue prototype)
     {
-        auto* result = Structure::create(vm, 0, prototype, TypeInfo(GlobalObjectType, StructureFlags), info());
+        auto* result = Structure::create(vm, nullptr, prototype, TypeInfo(GlobalObjectType, StructureFlags), info());
         result->setTransitionWatchpointIsLikelyToBeFired(true);
         return result;
     }
 
-    static JSInternalPromise* moduleLoaderImportModule(JSGlobalObject*, ExecState*, JSModuleLoader*, JSString* moduleNameValue, JSValue parameters, const SourceOrigin&);
-    static Identifier moduleLoaderResolve(JSGlobalObject*, ExecState*, JSModuleLoader*, JSValue keyValue, JSValue referrerValue, JSValue);
-    static JSInternalPromise* moduleLoaderFetch(JSGlobalObject*, ExecState*, JSModuleLoader*, JSValue, JSValue, JSValue);
-    static JSObject* moduleLoaderCreateImportMetaProperties(JSGlobalObject*, ExecState*, JSModuleLoader*, JSValue, JSModuleRecord*, JSValue);
-    static JSValue moduleLoaderEvaluate(JSGlobalObject*, ExecState*, JSModuleLoader*, JSValue, JSValue, JSValue);
+    static void reportUncaughtExceptionAtEventLoop(JSGlobalObject*, Exception*);
+
+    static JSInternalPromise* moduleLoaderImportModule(JSGlobalObject*, JSModuleLoader*, JSString* moduleNameValue, JSValue parameters, const SourceOrigin&);
+    static Identifier moduleLoaderResolve(JSGlobalObject*, JSModuleLoader*, JSValue keyValue, JSValue referrerValue, JSValue);
+    static JSInternalPromise* moduleLoaderFetch(JSGlobalObject*, JSModuleLoader*, JSValue, JSValue, JSValue);
+    static JSObject* moduleLoaderCreateImportMetaProperties(JSGlobalObject*, JSModuleLoader*, JSValue, JSModuleRecord*, JSValue);
+    static JSValue moduleLoaderEvaluate(JSGlobalObject*, JSModuleLoader*, JSValue, JSValue, JSValue);
 
     JSValue loadAndEvaluateJSScriptModule(const JSLockHolder&, JSScript *);