Changeset 27126 in webkit for trunk/JavaScriptCore/kjs/function.cpp

Timestamp:

Oct 26, 2007, 3:43:03 PM (18 years ago)

Author:

ggaren

Message:

Reviewed by Maciej Stachowiak.

Switched ActivationImp to using a symbol table. For now, though, all
clients take the slow path.

Net .6% speedup on SunSpider.

Slowdowns:

• ActivationImp now mallocs in its constructor
• Local variable hits use an extra level of indirection to retrieve data
• Local variable misses do two lookups

Speedups:

• Fast initialization of local variables upon function entry

• JavaScriptCore.xcodeproj/project.pbxproj: Added SymbolTable.h

• kjs/function.cpp: (KJS::ActivationImp::ActivationImp): Malloc a private structure to hold data that won't fit in a JSCell. (KJS::ActivationImp::argumentsGetter): Use slow symbol table path for lookup. (KJS::ActivationImp::getOwnPropertySlot): ditto (KJS::ActivationImp::deleteProperty): ditto (KJS::ActivationImp::put): ditto (KJS::ActivationImp::createArgumentsObject): ditto

(KJS::ActivationImp::mark): Call JSObject::mark first so that one of
our properties doesn't try to recursively mark us. (This caused a crash
in earlier testing. Not sure why we haven't run into it before.)

• kjs/nodes.cpp: Functions now build a symbol table the first time they're called. (KJS::VarDeclNode::evaluate): (KJS::FunctionBodyNode::FunctionBodyNode): (KJS::FunctionBodyNode::initializeSymbolTable): (KJS::FunctionBodyNode::processDeclarations): (KJS::FunctionBodyNode::processDeclarationsForFunctionCode): (KJS::FunctionBodyNode::processDeclarationsForProgramCode):

• kjs/nodes.h: (KJS::FunctionBodyNode::symbolTable):

• wtf/Forward.h: Added Vector.

File:

• trunk/JavaScriptCore/kjs/function.cpp (modified) (7 diffs)

trunk/JavaScriptCore/kjs/function.cpp

@@ -391 +391 @@
 const ClassInfo ActivationImp::info = {"Activation", 0, 0, 0};
 
-// ECMA 10.1.6
 ActivationImp::ActivationImp(FunctionImp* function, const List& arguments)
-    : _function(function), _arguments(arguments), _argumentsObject(0)
-{
-  // FIXME: Do we need to support enumerating the arguments property?
+    : d(new ActivationImpPrivate(function, arguments))
+    , symbolTable(&function->body->symbolTable())
+{
 }
 
@@ -401 +400 @@
 {
   ActivationImp* thisObj = static_cast<ActivationImp*>(slot.slotBase());
-
-  // default: return builtin arguments array
-  if (!thisObj->_argumentsObject)
+  ActivationImpPrivate* d = thisObj->d.get();
+  
+  if (!d->argumentsObject)
     thisObj->createArgumentsObject(exec);
   
-  return thisObj->_argumentsObject;
+  return d->argumentsObject;
 }
 
@@ -416 +415 @@
 bool ActivationImp::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
 {
-    // do this first so property map arguments property wins over the below
-    // we don't call JSObject because we won't have getter/setter properties
-    // and we don't want to support __proto__
+    // We don't call through to JSObject because there's no way to give an 
+    // acitvation object getter/setter properties, and exposing __proto__ in
+    // the scope chain would be bizarre.
+    ASSERT(!_prop.hasGetterSetterProperties());
+
+    size_t index;
+    if (symbolTable->get(propertyName, index)) {
+        slot.setValueSlot(this, &d->localStorage[index].value);
+        return true;
+    }
 
     if (JSValue** location = getDirectLocation(propertyName)) {
@@ -425 +431 @@
     }
 
+    // Only return the built-in arguments object if it wasn't overridden above.
     if (propertyName == exec->propertyNames().arguments) {
         slot.setCustom(this, getArgumentsGetter());
@@ -437 +444 @@
     if (propertyName == exec->propertyNames().arguments)
         return false;
+
+    size_t index;
+    if (symbolTable->get(propertyName, index))
+        return false;
+
     return JSObject::deleteProperty(exec, propertyName);
 }
@@ -442 +454 @@
 void ActivationImp::put(ExecState*, const Identifier& propertyName, JSValue* value, int attr)
 {
-  // There's no way that an activation object can have a prototype or getter/setter properties
+  // There's no way that an activation object can have a prototype or getter/setter properties.
   ASSERT(!_prop.hasGetterSetterProperties());
   ASSERT(prototype() == jsNull());
 
+  size_t index;
+  if (symbolTable->get(propertyName, index)) {
+    LocalStorageEntry& entry = d->localStorage[index];
+    entry.value = value;
+    entry.attributes = attr;
+    return;
+  }
+
   _prop.put(propertyName, value, attr, (attr == None || attr == DontDelete));
 }
@@ -451 +471 @@
 void ActivationImp::mark()
 {
-    if (_function && !_function->marked()) 
-        _function->mark();
-    if (_argumentsObject && !_argumentsObject->marked())
-        _argumentsObject->mark();
     JSObject::mark();
+
+    if (!d->function->marked())
+        d->function->mark();
+
+    size_t size = d->localStorage.size();
+    for (size_t i = 0; i < size; ++i) {
+        JSValue* value = d->localStorage[i].value;
+        if (!value->marked())
+            value->mark();
+    }
+
+    if (d->argumentsObject && !d->argumentsObject->marked())
+        d->argumentsObject->mark();
 }
 
 void ActivationImp::createArgumentsObject(ExecState* exec)
 {
-  _argumentsObject = new Arguments(exec, _function, _arguments, const_cast<ActivationImp*>(this));
-  // The arguments list is only needed to create the arguments object, so discard it now
-  _arguments.reset();
+  d->argumentsObject = new Arguments(exec, d->function, d->arguments, this);
+
+  // The arguments list is only needed to create the arguments object, so discard it now.
+  // This prevents lists of Lists from building up, waiting to be garbage collected.
+  d->arguments.reset();
 }