Changeset 266223 in webkit for trunk/Source/JavaScriptCore

Timestamp:

Aug 26, 2020, 10:27:16 PM (5 years ago)

Author:

Alexey Shvayka

Message:

Use jsTypeofIsObject() in DFG AI and operationTypeOfIsObject()
​https://bugs.webkit.org/show_bug.cgi?id=144457

Reviewed by Saam Barati.

Source/JavaScriptCore:

This patch refactors jsTypeofIsObject(), leveraging fast path of isCallable(),
moves it to the header, and utilizes it in operationTypeOfIsObject() & DFG AI
(minding concurrency) to eliminate code duplication.

Also, removes orphaned slow_path_is_object declaration.

No behavior change, typeof microbenchmarks are neutral.

• dfg/DFGAbstractInterpreterInlines.h:

(JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):

• dfg/DFGOperations.cpp:
• runtime/CommonSlowPaths.h:
• runtime/Operations.cpp:

(JSC::jsTypeofIsObject): Deleted.

• runtime/Operations.h:

(JSC::jsTypeofIsObjectWithConcurrency):
(JSC::jsTypeofIsObject):

Source/WTF:

• wtf/TriState.h:

(WTF::invert):

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• dfg/DFGAbstractInterpreterInlines.h (modified) (1 diff)
• dfg/DFGOperations.cpp (modified) (1 diff)
• runtime/CommonSlowPaths.h (modified) (1 diff)
• runtime/Operations.cpp (modified) (1 diff)
• runtime/Operations.h (modified) (2 diffs)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2020-08-26  Alexey Shvayka  <[email protected]>
+
+        Use jsTypeofIsObject() in DFG AI and operationTypeOfIsObject()
+        https://bugs.webkit.org/show_bug.cgi?id=144457
+
+        Reviewed by Saam Barati.
+
+        This patch refactors jsTypeofIsObject(), leveraging fast path of isCallable(),
+        moves it to the header, and utilizes it in operationTypeOfIsObject() & DFG AI
+        (minding concurrency) to eliminate code duplication.
+
+        Also, removes orphaned slow_path_is_object declaration.
+
+        No behavior change, `typeof` microbenchmarks are neutral.
+
+        * dfg/DFGAbstractInterpreterInlines.h:
+        (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
+        * dfg/DFGOperations.cpp:
+        * runtime/CommonSlowPaths.h:
+        * runtime/Operations.cpp:
+        (JSC::jsTypeofIsObject): Deleted.
+        * runtime/Operations.h:
+        (JSC::jsTypeofIsObjectWithConcurrency):
+        (JSC::jsTypeofIsObject):
+
 2020-08-26  Alexey Shvayka  <[email protected]>
 

trunk/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h

@@ -1477 +1477 @@
                     : child.value().isUndefined()));
                 break;
-            case TypeOfIsObject:
-                if (child.value().isObject()) {
-                    JSObject* object = asObject(child.value());
-                    if (object->type() == JSFunctionType)
-                        setConstant(node, jsBoolean(false));
-                    else if (!(object->inlineTypeFlags() & OverridesGetCallData))
-                        setConstant(node, jsBoolean(!child.value().asCell()->structure(m_vm)->masqueradesAsUndefined(m_codeBlock->globalObjectFor(node->origin.semantic))));
-                    else {
-                        // FIXME: This could just call getCallData.
-                        // https://bugs.webkit.org/show_bug.cgi?id=144457
-                        constantWasSet = false;
-                    }
-                } else
-                    setConstant(node, jsBoolean(child.value().isNull()));
-                break;
+            case TypeOfIsObject: {
+                TriState result = jsTypeofIsObjectWithConcurrency<Concurrency::ConcurrentThread>(m_codeBlock->globalObjectFor(node->origin.semantic), child.value());
+                if (result != TriState::Indeterminate)
+                    setConstant(node, jsBoolean(result == TriState::True));
+                else
+                    constantWasSet = false;
+                break;
+            }
             case TypeOfIsFunction: {
                 TriState result = jsTypeofIsFunctionWithConcurrency<Concurrency::ConcurrentThread>(m_codeBlock->globalObjectFor(node->origin.semantic), child.value());

trunk/Source/JavaScriptCore/dfg/DFGOperations.cpp

@@ -2133 +2133 @@
     ASSERT(jsDynamicCast<JSObject*>(vm, object));
     
-    if (object->structure(vm)->masqueradesAsUndefined(globalObject))
-        return false;
-    if (object->isCallable(vm))
-        return false;
-    return true;
+    return jsTypeofIsObject(globalObject, object);
 }
 

trunk/Source/JavaScriptCore/runtime/CommonSlowPaths.h

@@ -254 +254 @@
 SLOW_PATH_HIDDEN_DECL(slow_path_typeof_is_object);
 SLOW_PATH_HIDDEN_DECL(slow_path_typeof_is_function);
-SLOW_PATH_HIDDEN_DECL(slow_path_is_object);
 SLOW_PATH_HIDDEN_DECL(slow_path_is_callable);
 SLOW_PATH_HIDDEN_DECL(slow_path_is_constructor);

trunk/Source/JavaScriptCore/runtime/Operations.cpp

@@ -114 +114 @@
 }
 
-bool jsTypeofIsObject(JSGlobalObject* globalObject, JSValue v)
-{
-    VM& vm = globalObject->vm();
-    if (!v.isCell())
-        return v.isNull();
-
-    JSType type = v.asCell()->type();
-    if (type == StringType || type == SymbolType || type == HeapBigIntType)
-        return false;
-    if (type >= ObjectType) {
-        if (asObject(v)->structure(vm)->masqueradesAsUndefined(globalObject))
-            return false;
-        JSObject* object = asObject(v);
-        if (object->isCallable(vm))
-            return false;
-    }
-    return true;
-}
-
 size_t normalizePrototypeChain(JSGlobalObject* globalObject, JSCell* base, bool& sawPolyProto)
 {

trunk/Source/JavaScriptCore/runtime/Operations.h

@@ -33 +33 @@
 NEVER_INLINE JSValue jsAddSlowCase(JSGlobalObject*, JSValue, JSValue);
 JSString* jsTypeStringForValueWithConcurrency(VM&, JSGlobalObject*, JSValue, Concurrency);
-bool jsTypeofIsObject(JSGlobalObject*, JSValue);
 size_t normalizePrototypeChain(JSGlobalObject*, JSCell*, bool& sawPolyProto);
+
+template<Concurrency concurrency>
+ALWAYS_INLINE TriState jsTypeofIsObjectWithConcurrency(JSGlobalObject* globalObject, JSValue value)
+{
+    VM& vm = globalObject->vm();
+    if (!value.isObject())
+        return triState(value.isNull());
+    JSObject* object = asObject(value);
+    if (object->structure(vm)->masqueradesAsUndefined(globalObject))
+        return TriState::False;
+    return invert(object->isCallableWithConcurrency<concurrency>(vm));
+}
 
 template<Concurrency concurrency>
@@ -51 +62 @@
 {
     return jsTypeStringForValueWithConcurrency(getVM(globalObject), globalObject, value, Concurrency::MainThread);
+}
+
+ALWAYS_INLINE bool jsTypeofIsObject(JSGlobalObject* globalObject, JSValue value)
+{
+    auto result = jsTypeofIsObjectWithConcurrency<Concurrency::MainThread>(globalObject, value);
+    ASSERT(result != TriState::Indeterminate);
+    return result == TriState::True;
 }