Changeset 31119 in webkit for trunk/JavaScriptCore/kjs/nodes.cpp

Timestamp:

Mar 17, 2008, 10:36:26 PM (17 years ago)

Author:

[email protected]

Message:

Optimise multi-scope function call resolution

Reviewed by Geoff

Refactor multiscope variable resolution and use to add
optimised FunctionCallResolveNode subclasses.

2.6% gain in sunspider performance, *25%* gain in controlflow-recursive

File:

• trunk/JavaScriptCore/kjs/nodes.cpp (modified) (9 diffs)

trunk/JavaScriptCore/kjs/nodes.cpp

@@ -594 +594 @@
 }
 
-void ResolveNode::optimizeVariableAccess(ExecState* exec, const SymbolTable& symbolTable, const LocalStorage&, NodeStack&)
-{
-    size_t index = symbolTable.get(m_ident.ustring().rep());
+static size_t getSymbolTableEntry(ExecState* exec, const Identifier& ident, const SymbolTable& symbolTable, size_t& stackDepth) 
+{
+    size_t index = symbolTable.get(ident.ustring().rep());
     if (index != missingSymbolMarker()) {
-        new (this) LocalVarAccessNode(index);
-        return;
+        stackDepth = 0;
+        return index;
     }
     
-    if (m_ident == exec->propertyNames().arguments)
-        return;
+    if (ident == exec->propertyNames().arguments) {
+        stackDepth = 0;
+        return missingSymbolMarker();
+    }
+    
     const ScopeChain& chain = exec->scopeChain();
     ScopeChainIterator iter = chain.begin();
@@ -613 +616 @@
             break;
         JSVariableObject* currentVariableObject = static_cast<JSVariableObject*>(currentScope);
-        index = currentVariableObject->symbolTable().get(m_ident.ustring().rep());
+        index = currentVariableObject->symbolTable().get(ident.ustring().rep());
         if (index != missingSymbolMarker()) {
-            new (this) ScopedVarAccessNode(index, depth);
-            return;
+            stackDepth = depth;
+            return index;
         }
         if (currentVariableObject->isDynamicScope())
             break;
     }
-    if (depth > 0)
-        new (this) NonLocalVarAccessNode(depth);
+    stackDepth = depth;
+    return missingSymbolMarker();
+}
+
+void ResolveNode::optimizeVariableAccess(ExecState* exec, const SymbolTable& symbolTable, const LocalStorage&, NodeStack&)
+{
+    size_t depth = 0;
+    size_t index = getSymbolTableEntry(exec, m_ident, symbolTable, depth);
+    if (index != missingSymbolMarker()) {
+        if (!depth)
+            new (this) LocalVarAccessNode(index);
+        else
+            new (this) ScopedVarAccessNode(index, depth);
+        return;
+    }
+
+    if (!depth)
+        return;
+
+    new (this) NonLocalVarAccessNode(depth);
 }
 
@@ -656 +677 @@
 }
 
-JSValue* ScopedVarAccessNode::inlineEvaluate(ExecState* exec)
+static inline JSValue* getNonLocalSymbol(ExecState* exec, size_t index, size_t scopeDepth)
 {
     const ScopeChain& chain = exec->scopeChain();
     ScopeChainIterator iter = chain.begin();
-    for (size_t i = 0; i < m_scopeDepth; ++iter, ++i)
+    for (size_t i = 0; i < scopeDepth; ++iter, ++i)
         ASSERT(iter != chain.end());
     JSObject* scope = *iter;
-    ASSERT(scope->isActivationObject() || scope->isGlobalObject());
+    ASSERT(scope->isVariableObject());
     JSVariableObject* variableObject = static_cast<JSVariableObject*>(scope);
-    return variableObject->localStorage()[m_index].value;
+    return variableObject->localStorage()[index].value;
+}
+
+JSValue* ScopedVarAccessNode::inlineEvaluate(ExecState* exec)
+{
+    return getNonLocalSymbol(exec, m_index, m_scopeDepth);
 }
 
@@ -1062 +1088 @@
 }
 
-template <ExpressionNode::CallerType callerType> 
-inline JSValue* ExpressionNode::resolveAndCall(ExecState* exec, const Identifier& ident, ArgumentsNode* args)
+template <ExpressionNode::CallerType callerType, bool scopeDepthIsZero> 
+inline JSValue* ExpressionNode::resolveAndCall(ExecState* exec, const Identifier& ident, ArgumentsNode* args, size_t scopeDepth)
 {
     const ScopeChain& chain = exec->scopeChain();
@@ -1069 +1095 @@
     ScopeChainIterator end = chain.end();
 
+    if (!scopeDepthIsZero) {
+        for (size_t i = 0; i < scopeDepth; ++iter, ++i)
+            ASSERT(iter != chain.end());
+    }
+    
     // we must always have something in the scope chain
     ASSERT(iter != end);
@@ -1123 +1154 @@
 JSValue* EvalFunctionCallNode::evaluate(ExecState* exec)
 {
-    return resolveAndCall<EvalOperator>(exec, exec->propertyNames().eval, m_args.get());
+    return resolveAndCall<EvalOperator, true>(exec, exec->propertyNames().eval, m_args.get());
 }
 
@@ -1157 +1188 @@
 }
 
-void FunctionCallResolveNode::optimizeVariableAccess(ExecState*, const SymbolTable& symbolTable, const LocalStorage&, NodeStack& nodeStack)
+void FunctionCallResolveNode::optimizeVariableAccess(ExecState* exec, const SymbolTable& symbolTable, const LocalStorage&, NodeStack& nodeStack)
 {
     nodeStack.append(m_args.get());
 
-    size_t index = symbolTable.get(m_ident.ustring().rep());
-    if (index != missingSymbolMarker())
-        new (this) LocalVarFunctionCallNode(index);
+    size_t depth = 0;
+    size_t index = getSymbolTableEntry(exec, m_ident, symbolTable, depth);
+    if (index != missingSymbolMarker()) {
+        if (!depth)
+            new (this) LocalVarFunctionCallNode(index);
+        else
+            new (this) ScopedVarFunctionCallNode(index, depth);
+        return;
+    }
+    
+    if (!depth)
+        return;
+    
+    new (this) NonLocalVarFunctionCallNode(depth);
 }
 
@@ -1172 +1214 @@
     ASSERT(!canSkipLookup(exec, m_ident));
 
-    return resolveAndCall<FunctionCall>(exec, m_ident, m_args.get());
+    return resolveAndCall<FunctionCall, true>(exec, m_ident, m_args.get());
 }
 
@@ -1255 +1297 @@
 
 uint32_t LocalVarFunctionCallNode::evaluateToUInt32(ExecState* exec)
+{
+    JSValue* v = inlineEvaluate(exec);
+    KJS_CHECKEXCEPTIONNUMBER
+    return v->toUInt32(exec);
+}
+
+JSValue* ScopedVarFunctionCallNode::inlineEvaluate(ExecState* exec)
+{
+    ASSERT(exec->variableObject() == exec->scopeChain().top());
+    
+    JSValue* v = getNonLocalSymbol(exec, m_index, m_scopeDepth);
+    
+    if (!v->isObject())
+        return throwError(exec, TypeError, "Value %s (result of expression %s) is not object.", v, m_ident);
+    
+    JSObject* func = static_cast<JSObject*>(v);
+    if (!func->implementsCall())
+        return throwError(exec, TypeError, "Object %s (result of expression %s) does not allow calls.", v, m_ident);
+    
+    List argList;
+    m_args->evaluateList(exec, argList);
+    KJS_CHECKEXCEPTIONVALUE
+    
+    return func->call(exec, exec->dynamicGlobalObject(), argList);
+}
+
+JSValue* ScopedVarFunctionCallNode::evaluate(ExecState* exec)
+{
+    return inlineEvaluate(exec);
+}
+
+double ScopedVarFunctionCallNode::evaluateToNumber(ExecState* exec)
+{
+    JSValue* v = inlineEvaluate(exec);
+    KJS_CHECKEXCEPTIONNUMBER
+    return v->toNumber(exec);
+}
+
+bool ScopedVarFunctionCallNode::evaluateToBoolean(ExecState* exec)
+{
+    JSValue* v = inlineEvaluate(exec);
+    KJS_CHECKEXCEPTIONBOOLEAN
+    return v->toBoolean(exec);
+}
+
+int32_t ScopedVarFunctionCallNode::evaluateToInt32(ExecState* exec)
+{
+    JSValue* v = inlineEvaluate(exec);
+    KJS_CHECKEXCEPTIONNUMBER
+    return v->toInt32(exec);
+}
+
+uint32_t ScopedVarFunctionCallNode::evaluateToUInt32(ExecState* exec)
+{
+    JSValue* v = inlineEvaluate(exec);
+    KJS_CHECKEXCEPTIONNUMBER
+    return v->toUInt32(exec);
+}
+
+JSValue* NonLocalVarFunctionCallNode::inlineEvaluate(ExecState* exec)
+{
+    // Check for missed optimization opportunity.
+    ASSERT(!canSkipLookup(exec, m_ident));
+    
+    return resolveAndCall<FunctionCall, false>(exec, m_ident, m_args.get(), m_scopeDepth);
+}
+
+JSValue* NonLocalVarFunctionCallNode::evaluate(ExecState* exec)
+{
+    return inlineEvaluate(exec);
+}
+
+double NonLocalVarFunctionCallNode::evaluateToNumber(ExecState* exec)
+{
+    JSValue* v = inlineEvaluate(exec);
+    KJS_CHECKEXCEPTIONNUMBER
+    return v->toNumber(exec);
+}
+
+bool NonLocalVarFunctionCallNode::evaluateToBoolean(ExecState* exec)
+{
+    JSValue* v = inlineEvaluate(exec);
+    KJS_CHECKEXCEPTIONBOOLEAN
+    return v->toBoolean(exec);
+}
+
+int32_t NonLocalVarFunctionCallNode::evaluateToInt32(ExecState* exec)
+{
+    JSValue* v = inlineEvaluate(exec);
+    KJS_CHECKEXCEPTIONNUMBER
+    return v->toInt32(exec);
+}
+
+uint32_t NonLocalVarFunctionCallNode::evaluateToUInt32(ExecState* exec)
 {
     JSValue* v = inlineEvaluate(exec);