Changeset 41100 in webkit for trunk/JavaScriptCore/runtime

Timestamp:

Feb 19, 2009, 10:04:21 PM (16 years ago)

Author:

[email protected]

Message:

2009-02-19 Geoffrey Garen <​[email protected]>

Reviewed by Gavin Barraclough.

First step in splitting JIT functionality out of the Interpreter class:
Created JITStubs.h/.cpp, and moved Interpreter::cti_* into JITStubs.cpp.

Functions that the Interpreter and JITStubs share moved to Operations.h/.cpp.

• GNUmakefile.am:
• JavaScriptCore.pri:
• JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
• JavaScriptCore.xcodeproj/project.pbxproj:
• interpreter/Interpreter.cpp: (JSC::Interpreter::resolveBase): (JSC::Interpreter::checkTimeout): (JSC::Interpreter::privateExecute):
• interpreter/Interpreter.h:
• jit/JITStubs.cpp: Copied from interpreter/Interpreter.cpp. (JSC::Interpreter::cti_op_resolve_base):
• jit/JITStubs.h: Copied from interpreter/Interpreter.h.
• runtime/Operations.cpp: (JSC::jsAddSlowCase): (JSC::jsTypeStringForValue): (JSC::jsIsObjectType): (JSC::jsIsFunctionType):
• runtime/Operations.h: (JSC::jsLess): (JSC::jsLessEq): (JSC::jsAdd): (JSC::cachePrototypeChain): (JSC::countPrototypeChainEntriesAndCheckForProxies): (JSC::resolveBase):

Location:

trunk/JavaScriptCore/runtime

Files:

• Operations.cpp (modified) (1 diff)
• Operations.h (modified) (3 diffs)

trunk/JavaScriptCore/runtime/Operations.cpp

@@ -53 +53 @@
 }
 
+NEVER_INLINE JSValuePtr jsAddSlowCase(CallFrame* callFrame, JSValuePtr v1, JSValuePtr v2)
+{
+    // exception for the Date exception in defaultValue()
+    JSValuePtr p1 = v1.toPrimitive(callFrame);
+    JSValuePtr p2 = v2.toPrimitive(callFrame);
+
+    if (p1.isString() || p2.isString()) {
+        RefPtr<UString::Rep> value = concatenate(p1.toString(callFrame).rep(), p2.toString(callFrame).rep());
+        if (!value)
+            return throwOutOfMemoryError(callFrame);
+        return jsString(callFrame, value.release());
+    }
+
+    return jsNumber(callFrame, p1.toNumber(callFrame) + p2.toNumber(callFrame));
+}
+
+JSValuePtr jsTypeStringForValue(CallFrame* callFrame, JSValuePtr v)
+{
+    if (v.isUndefined())
+        return jsNontrivialString(callFrame, "undefined");
+    if (v.isBoolean())
+        return jsNontrivialString(callFrame, "boolean");
+    if (v.isNumber())
+        return jsNontrivialString(callFrame, "number");
+    if (v.isString())
+        return jsNontrivialString(callFrame, "string");
+    if (v.isObject()) {
+        // Return "undefined" for objects that should be treated
+        // as null when doing comparisons.
+        if (asObject(v)->structure()->typeInfo().masqueradesAsUndefined())
+            return jsNontrivialString(callFrame, "undefined");
+        CallData callData;
+        if (asObject(v)->getCallData(callData) != CallTypeNone)
+            return jsNontrivialString(callFrame, "function");
+    }
+    return jsNontrivialString(callFrame, "object");
+}
+
+bool jsIsObjectType(JSValuePtr v)
+{
+    if (!v.isCell())
+        return v.isNull();
+
+    JSType type = asCell(v)->structure()->typeInfo().type();
+    if (type == NumberType || type == StringType)
+        return false;
+    if (type == ObjectType) {
+        if (asObject(v)->structure()->typeInfo().masqueradesAsUndefined())
+            return false;
+        CallData callData;
+        if (asObject(v)->getCallData(callData) != CallTypeNone)
+            return false;
+    }
+    return true;
+}
+
+bool jsIsFunctionType(JSValuePtr v)
+{
+    if (v.isObject()) {
+        CallData callData;
+        if (asObject(v)->getCallData(callData) != CallTypeNone)
+            return true;
+    }
+    return false;
+}
+
 } // namespace JSC

trunk/JavaScriptCore/runtime/Operations.h

@@ -23 +23 @@
 #define Operations_h
 
+#include "Interpreter.h"
 #include "JSImmediate.h"
 #include "JSNumberCell.h"
@@ -28 +29 @@
 
 namespace JSC {
+
+    NEVER_INLINE JSValuePtr throwOutOfMemoryError(ExecState*);
+    NEVER_INLINE JSValuePtr jsAddSlowCase(CallFrame*, JSValuePtr, JSValuePtr);
+    JSValuePtr jsTypeStringForValue(CallFrame*, JSValuePtr);
+    bool jsIsObjectType(JSValuePtr);
+    bool jsIsFunctionType(JSValuePtr);
 
     // ECMA 11.9.3
@@ -130 +137 @@
     }
 
-    JSValuePtr throwOutOfMemoryError(ExecState*);
-
-}
-#endif
+    inline bool jsLess(CallFrame* callFrame, JSValuePtr v1, JSValuePtr v2)
+    {
+        if (JSValuePtr::areBothInt32Fast(v1, v2))
+            return v1.getInt32Fast() < v2.getInt32Fast();
+
+        double n1;
+        double n2;
+        if (v1.getNumber(n1) && v2.getNumber(n2))
+            return n1 < n2;
+
+        Interpreter* interpreter = callFrame->interpreter();
+        if (interpreter->isJSString(v1) && interpreter->isJSString(v2))
+            return asString(v1)->value() < asString(v2)->value();
+
+        JSValuePtr p1;
+        JSValuePtr p2;
+        bool wasNotString1 = v1.getPrimitiveNumber(callFrame, n1, p1);
+        bool wasNotString2 = v2.getPrimitiveNumber(callFrame, n2, p2);
+
+        if (wasNotString1 | wasNotString2)
+            return n1 < n2;
+
+        return asString(p1)->value() < asString(p2)->value();
+    }
+
+    inline bool jsLessEq(CallFrame* callFrame, JSValuePtr v1, JSValuePtr v2)
+    {
+        if (JSValuePtr::areBothInt32Fast(v1, v2))
+            return v1.getInt32Fast() <= v2.getInt32Fast();
+
+        double n1;
+        double n2;
+        if (v1.getNumber(n1) && v2.getNumber(n2))
+            return n1 <= n2;
+
+        Interpreter* interpreter = callFrame->interpreter();
+        if (interpreter->isJSString(v1) && interpreter->isJSString(v2))
+            return !(asString(v2)->value() < asString(v1)->value());
+
+        JSValuePtr p1;
+        JSValuePtr p2;
+        bool wasNotString1 = v1.getPrimitiveNumber(callFrame, n1, p1);
+        bool wasNotString2 = v2.getPrimitiveNumber(callFrame, n2, p2);
+
+        if (wasNotString1 | wasNotString2)
+            return n1 <= n2;
+
+        return !(asString(p2)->value() < asString(p1)->value());
+    }
+
+    // Fast-path choices here are based on frequency data from SunSpider:
+    //    <times> Add case: <t1> <t2>
+    //    ---------------------------
+    //    5626160 Add case: 3 3 (of these, 3637690 are for immediate values)
+    //    247412  Add case: 5 5
+    //    20900   Add case: 5 6
+    //    13962   Add case: 5 3
+    //    4000    Add case: 3 5
+
+    ALWAYS_INLINE JSValuePtr jsAdd(CallFrame* callFrame, JSValuePtr v1, JSValuePtr v2)
+    {
+        double left;
+        double right = 0.0;
+
+        bool rightIsNumber = v2.getNumber(right);
+        if (rightIsNumber && v1.getNumber(left))
+            return jsNumber(callFrame, left + right);
+        
+        bool leftIsString = v1.isString();
+        if (leftIsString && v2.isString()) {
+            RefPtr<UString::Rep> value = concatenate(asString(v1)->value().rep(), asString(v2)->value().rep());
+            if (!value)
+                return throwOutOfMemoryError(callFrame);
+            return jsString(callFrame, value.release());
+        }
+
+        if (rightIsNumber & leftIsString) {
+            RefPtr<UString::Rep> value = v2.isInt32Fast() ?
+                concatenate(asString(v1)->value().rep(), v2.getInt32Fast()) :
+                concatenate(asString(v1)->value().rep(), right);
+
+            if (!value)
+                return throwOutOfMemoryError(callFrame);
+            return jsString(callFrame, value.release());
+        }
+
+        // All other cases are pretty uncommon
+        return jsAddSlowCase(callFrame, v1, v2);
+    }
+
+    inline StructureChain* cachePrototypeChain(CallFrame* callFrame, Structure* structure)
+    {
+        JSValuePtr prototype = structure->prototypeForLookup(callFrame);
+        if (!prototype.isCell())
+            return 0;
+        RefPtr<StructureChain> chain = StructureChain::create(asObject(prototype)->structure());
+        structure->setCachedPrototypeChain(chain.release());
+        return structure->cachedPrototypeChain();
+    }
+
+    inline size_t countPrototypeChainEntriesAndCheckForProxies(CallFrame* callFrame, JSValuePtr baseValue, const PropertySlot& slot)
+    {
+        JSCell* cell = asCell(baseValue);
+        size_t count = 0;
+
+        while (slot.slotBase() != cell) {
+            JSValuePtr v = cell->structure()->prototypeForLookup(callFrame);
+
+            // If we didn't find slotBase in baseValue's prototype chain, then baseValue
+            // must be a proxy for another object.
+
+            if (v.isNull())
+                return 0;
+
+            cell = asCell(v);
+
+            // Since we're accessing a prototype in a loop, it's a good bet that it
+            // should not be treated as a dictionary.
+            if (cell->structure()->isDictionary()) {
+                RefPtr<Structure> transition = Structure::fromDictionaryTransition(cell->structure());
+                asObject(cell)->setStructure(transition.release());
+                cell->structure()->setCachedPrototypeChain(0);
+            }
+
+            ++count;
+        }
+        
+        ASSERT(count);
+        return count;
+    }
+
+    ALWAYS_INLINE JSValuePtr resolveBase(CallFrame* callFrame, Identifier& property, ScopeChainNode* scopeChain)
+    {
+        ScopeChainIterator iter = scopeChain->begin();
+        ScopeChainIterator next = iter;
+        ++next;
+        ScopeChainIterator end = scopeChain->end();
+        ASSERT(iter != end);
+
+        PropertySlot slot;
+        JSObject* base;
+        while (true) {
+            base = *iter;
+            if (next == end || base->getPropertySlot(callFrame, property, slot))
+                return base;
+
+            iter = next;
+            ++next;
+        }
+
+        ASSERT_NOT_REACHED();
+        return noValue();
+    }
+
+} // namespace JSC
+
+#endif // Operations_h