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

Timestamp:

Oct 28, 2007, 10:32:23 PM (18 years ago)

Author:

ggaren

Message:

Reviewed by Darin Adler.

Added FunctionCallResolveNode, PostfixResolveNode, and DeleteResolveNode
to the AST transfom that replaces slow resolve nodes with fast local
variable alternatives.

2.5% speedup on SunSpider.

Also added some missing copyright notices.

• kjs/nodes.cpp: (KJS::FunctionCallResolveNode::optimizeVariableAccess): (KJS::FunctionCallResolveNode::evaluate): (KJS::LocalVarFunctionCallNode::evaluate): (KJS::PostfixResolveNode::optimizeVariableAccess): (KJS::PostfixResolveNode::evaluate): (KJS::LocalVarPostfixNode::evaluate): (KJS::DeleteResolveNode::optimizeVariableAccess): (KJS::DeleteResolveNode::evaluate): (KJS::LocalVarDeleteNode::evaluate):
• kjs/nodes.h: (KJS::FunctionCallResolveNode::): (KJS::LocalVarFunctionCallNode::LocalVarFunctionCallNode): (KJS::PostfixResolveNode::): (KJS::LocalVarPostfixNode::LocalVarPostfixNode): (KJS::DeleteResolveNode::): (KJS::LocalVarDeleteNode::LocalVarDeleteNode):

File:

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

trunk/JavaScriptCore/kjs/nodes.cpp

@@ -4 +4 @@
  *  Copyright (C) 2003, 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  *  Copyright (C) 2007 Cameron Zwarich ([email protected])
+ *  Copyright (C) 2007 Maks Orlovich
  *
  *  This library is free software; you can redistribute it and/or
@@ -60 +61 @@
   }
 
+#if !ASSERT_DISABLED
+static inline bool canSkipLookup(ExecState* exec, const Identifier& ident)
+{
+    // Static lookup in EvalCode is impossible because variables aren't DontDelete. 
+    // Static lookup in GlobalCode may be possible, but we haven't implemented support for it yet.
+    if (exec->codeType() != FunctionCode)
+        return false;
+
+    // Static lookup is impossible when something dynamic has been added to the front of the scope chain.
+    if (exec->variableObject() != exec->scopeChain().top())
+        return false;
+
+    ASSERT(exec->variableObject()->isActivation()); // Because this is function code.
+
+    // Static lookup is impossible if the symbol isn't statically declared.
+    if (!static_cast<ActivationImp*>(exec->variableObject())->symbolTable().contains(ident.ustring().rep()))
+        return false;
+        
+    return true;
+}
+#endif
+
 // ------------------------------ Node -----------------------------------------
 
@@ -375 +398 @@
 {
   // Check for missed optimization opportunity.
-  ASSERT(exec->codeType() != FunctionCode
-         || exec->variableObject() != exec->scopeChain().top() 
-         || (exec->variableObject()->isActivation() && !static_cast<ActivationImp*>(exec->variableObject())->symbolTable().contains(ident.ustring().rep())));
+  ASSERT(!canSkipLookup(exec, ident));
 
   const ScopeChain& chain = exec->scopeChain();
@@ -697 +718 @@
 }
 
-void FunctionCallResolveNode::optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack& nodeStack)
+void FunctionCallResolveNode::optimizeVariableAccess(FunctionBodyNode* functionBody, DeclarationStacks::NodeStack& nodeStack)
 {
     nodeStack.append(args.get());
+
+    size_t index = functionBody->symbolTable().get(ident.ustring().rep());
+    if (index != missingSymbolMarker())
+        new (this) LocalVarFunctionCallNode(index);
 }
 
@@ -705 +730 @@
 JSValue *FunctionCallResolveNode::evaluate(ExecState *exec)
 {
+  // Check for missed optimization opportunity.
+  ASSERT(!canSkipLookup(exec, ident));
+
   const ScopeChain& chain = exec->scopeChain();
   ScopeChainIterator iter = chain.begin();
@@ -751 +779 @@
 }
 
+JSValue* LocalVarFunctionCallNode::evaluate(ExecState* exec)
+{
+    ActivationImp* variableObject = static_cast<ActivationImp*>(exec->variableObject());
+    ASSERT(variableObject->isActivation());
+    ASSERT(variableObject == exec->scopeChain().top());
+
+    JSValue* v = variableObject->localStorage()[index].value;
+
+    if (!v->isObject())
+        return throwError(exec, TypeError, "Value %s (result of expression %s) is not object.", v, 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, ident);
+      
+    List argList = args->evaluateList(exec);
+    KJS_CHECKEXCEPTIONVALUE
+
+    return func->call(exec, exec->dynamicInterpreter()->globalObject(), argList);
+}
+
 void FunctionCallBracketNode::optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack& nodeStack)
 {
@@ -859 +908 @@
 // ------------------------------ PostfixResolveNode ----------------------------------
 
+void PostfixResolveNode::optimizeVariableAccess(FunctionBodyNode* functionBody, DeclarationStacks::NodeStack&)
+{
+    size_t index = functionBody->symbolTable().get(m_ident.ustring().rep());
+    if (index != missingSymbolMarker())
+        new (this) LocalVarPostfixNode(index);
+}
+
 JSValue *PostfixResolveNode::evaluate(ExecState *exec)
 {
+  // Check for missed optimization opportunity.
+  ASSERT(!canSkipLookup(exec, m_ident));
+
   const ScopeChain& chain = exec->scopeChain();
   ScopeChainIterator iter = chain.begin();
@@ -889 +948 @@
 }
 
+JSValue* LocalVarPostfixNode::evaluate(ExecState* exec)
+{
+    ActivationImp* variableObject = static_cast<ActivationImp*>(exec->variableObject());
+    ASSERT(variableObject->isActivation());
+    ASSERT(variableObject == exec->scopeChain().top());
+
+    JSValue** v = &variableObject->localStorage()[index].value;
+    double n = (*v)->toNumber(exec);
+    double newValue = (m_oper == OpPlusPlus) ? n + 1 : n - 1;
+    *v = jsNumber(newValue);
+    return jsNumber(n);
+}
+
 // ------------------------------ PostfixBracketNode ----------------------------------
 
@@ -970 +1042 @@
 // ------------------------------ DeleteResolveNode -----------------------------------
 
+void DeleteResolveNode::optimizeVariableAccess(FunctionBodyNode* functionBody, DeclarationStacks::NodeStack&)
+{
+    size_t index = functionBody->symbolTable().get(m_ident.ustring().rep());
+    if (index != missingSymbolMarker())
+        new (this) LocalVarDeleteNode();
+}
+
 // ECMA 11.4.1
 
 JSValue *DeleteResolveNode::evaluate(ExecState *exec)
 {
+  // Check for missed optimization opportunity.
+  ASSERT(!canSkipLookup(exec, m_ident));
+
   const ScopeChain& chain = exec->scopeChain();
   ScopeChainIterator iter = chain.begin();
@@ -993 +1075 @@
 
   return jsBoolean(true);
+}
+
+JSValue* LocalVarDeleteNode::evaluate(ExecState*)
+{
+    return jsBoolean(false);
 }