Changeset 29067 in webkit for trunk/JavaScriptCore/kjs/ExecState.cpp

Timestamp:

Jan 1, 2008, 11:35:37 AM (17 years ago)

Author:

Darin Adler

Message:

Reviewed by Geoff.

• ​http://bugs.webkit.org/show_bug.cgi?id=16685 eliminate List::empty() to cut down on PIC branches

Also included one other speed-up -- remove the call to reserveCapacity from
FunctionBodyNode::processDeclarations in all but the most unusual cases.

Together these make SunSpider 1.016x as fast.

• JavaScriptCore.exp: Updated.
• kjs/ExecState.cpp: (KJS::globalEmptyList): Added. Called only when creating global ExecState instances. (KJS::ExecState::ExecState): Broke constructor up into three separate functions, for the three separate node types. Also went through each of the three and streamlined as much as possible, removing dead code. This prevents us from having to access the global in the function body version of the constructor.

• kjs/ExecState.h: Added emptyList(). Replaced the constructor with a set of three that are specific to the different node types that can create new execution state objects.

• kjs/array_object.cpp: (KJS::ArrayProtoFuncToLocaleString::callAsFunction): Use exec->emptyList() instead of List::empty(). (KJS::ArrayProtoFuncConcat::callAsFunction): Ditto. (KJS::ArrayProtoFuncSlice::callAsFunction): Ditto. (KJS::ArrayProtoFuncSplice::callAsFunction): Ditto. (KJS::ArrayProtoFuncFilter::callAsFunction): Ditto.
• kjs/function.cpp: (KJS::FunctionImp::callAsFunction): Updated to call new ExecState constructor. (KJS::GlobalFuncImp::callAsFunction): Ditto (for eval).
• kjs/function_object.cpp: (FunctionObjectImp::construct): Use exec->emptyList() instead of List::empty().

• kjs/list.cpp: Removed List::empty.
• kjs/list.h: Ditto.

• kjs/nodes.cpp: (KJS::ElementNode::evaluate): Use exec->emptyList() instead of List::empty(). (KJS::ArrayNode::evaluate): Ditto. (KJS::ObjectLiteralNode::evaluate): Ditto. (KJS::PropertyListNode::evaluate): Ditto. (KJS::FunctionBodyNode::processDeclarations): Another speed-up. Check the capacity before calling reserveCapacity, because it doesn't get inlined the local storage vector is almost always big enough -- saving the function call overhead is a big deal. (KJS::FuncDeclNode::makeFunction): Use exec->emptyList() instead of List::empty(). (KJS::FuncExprNode::evaluate): Ditto.
• kjs/object.cpp: (KJS::tryGetAndCallProperty): Ditto.
• kjs/property_slot.cpp: (KJS::PropertySlot::functionGetter): Ditto.
• kjs/string_object.cpp: (KJS::StringProtoFuncSplit::callAsFunction): Ditto.

File:

• trunk/JavaScriptCore/kjs/ExecState.cpp (modified) (1 diff)

trunk/JavaScriptCore/kjs/ExecState.cpp

@@ -32 +32 @@
 namespace KJS {
 
+static inline List* globalEmptyList()
+{
+    static List staticEmptyList;
+    return &staticEmptyList;
+}
+
 // ECMA 10.2
-ExecState::ExecState(JSGlobalObject* globalObject, JSObject* thisV, 
-                     ScopeNode* scopeNode, CodeType type, ExecState* callingExec, ExecState* currentExec,
-                     FunctionImp* func, const List* args)
+
+ExecState::ExecState(JSGlobalObject* globalObject, JSObject* /*thisObject*/, ProgramNode* programNode)
     : m_globalObject(globalObject)
     , m_exception(0)
     , m_propertyNames(CommonIdentifiers::shared())
-    , m_callingExec(callingExec)
-    , m_savedExec(currentExec)
-    , m_scopeNode(scopeNode)
-    , m_function(func)
-    , m_arguments(args)
+    , m_emptyList(globalEmptyList())
+    , m_callingExec(0)
+    , m_savedExec(0)
+    , m_scopeNode(programNode)
+    , m_function(0)
+    , m_arguments(0)
+    , m_activation(0)
+    , m_localStorage(&globalObject->localStorage())
+    , m_variableObject(globalObject)
+    , m_thisVal(globalObject)
     , m_iterationDepth(0)
     , m_switchDepth(0) 
-    , m_codeType(type)
+    , m_codeType(GlobalCode)
 {
-    // create and initialize activation object (ECMA 10.1.6)
-    if (type == FunctionCode) {
-        m_activation = new ActivationImp(this);
-        m_variableObject = m_activation;
-    } else {
-        m_activation = 0;
-        m_variableObject = globalObject;
-    }
-    
-    // ECMA 10.2
-    switch(type) {
-    case EvalCode:
-        if (m_callingExec) {
-            m_scopeChain = m_callingExec->scopeChain();
-            m_variableObject = m_callingExec->variableObject();
-            m_thisVal = m_callingExec->thisValue();
-            break;
-        } // else same as GlobalCode
-    case GlobalCode:
-        m_scopeChain.push(globalObject);
-        m_thisVal = globalObject;
-        break;
-    case FunctionCode:
-        m_scopeChain = func->scope();
-        m_scopeChain.push(m_activation);
-        m_variableObject = m_activation;
-        m_thisVal = thisV;
-        break;
-    }
-    
-    m_localStorage = &m_variableObject->localStorage();
+    // FIXME: This function ignores the "thisObject" parameter, which means that the API for evaluating
+    // a script with a this object that's not the same as the global object is broken, and probably
+    // has been for some time.
+    m_scopeChain.push(globalObject);
+    if (programNode)
+        globalObject->setCurrentExec(this);
+}
 
-    if (scopeNode)
-        m_globalObject->setCurrentExec(this);
+ExecState::ExecState(JSGlobalObject* globalObject, EvalNode* evalNode, ExecState* callingExec)
+    : m_globalObject(globalObject)
+    , m_exception(0)
+    , m_propertyNames(callingExec->m_propertyNames)
+    , m_emptyList(callingExec->m_emptyList)
+    , m_callingExec(callingExec)
+    , m_savedExec(globalObject->currentExec())
+    , m_scopeNode(evalNode)
+    , m_function(0)
+    , m_arguments(0)
+    , m_activation(0)
+    , m_localStorage(callingExec->m_localStorage)
+    , m_scopeChain(callingExec->m_scopeChain)
+    , m_variableObject(callingExec->m_variableObject)
+    , m_thisVal(callingExec->m_thisVal)
+    , m_iterationDepth(0)
+    , m_switchDepth(0) 
+    , m_codeType(EvalCode)
+{    
+    globalObject->setCurrentExec(this);
+}
+
+ExecState::ExecState(JSGlobalObject* globalObject, JSObject* thisObject, 
+                     FunctionBodyNode* functionBodyNode, ExecState* callingExec,
+                     FunctionImp* func, const List& args)
+    : m_globalObject(globalObject)
+    , m_exception(0)
+    , m_propertyNames(callingExec->m_propertyNames)
+    , m_emptyList(callingExec->m_emptyList)
+    , m_callingExec(callingExec)
+    , m_savedExec(globalObject->currentExec())
+    , m_scopeNode(functionBodyNode)
+    , m_function(func)
+    , m_arguments(&args)
+    , m_scopeChain(func->scope())
+    , m_thisVal(thisObject)
+    , m_iterationDepth(0)
+    , m_switchDepth(0) 
+    , m_codeType(FunctionCode)
+{
+    ActivationImp* activation = new ActivationImp(this);
+    m_activation = activation;
+    m_localStorage = &activation->localStorage();
+    m_variableObject = activation;
+    m_scopeChain.push(activation);
+    globalObject->setCurrentExec(this);
 }