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

Timestamp:

Nov 20, 2002, 4:55:08 PM (23 years ago)

Author:

darin

Message:

• created argument list objects only on demand for a 7.5% speedup

• kjs/function.h: Change ActivationImp around.
• kjs/function.cpp: (FunctionImp::call): Pass a pointer to the arguments list to avoid ref/unref. (FunctionImp::get): Get the function pointer from the context directly, not the activation object. (ArgumentsImp::ArgumentsImp): Add an overload that takes no arguments. (ActivationImp::ActivationImp): Store a context pointer and an arguments object pointer. (ActivationImp::get): Special case for arguments, create it and return it. (ActivationImp::put): Special case for arguments, can't be set. (ActivationImp::hasProperty): Special case for arguments, return true. (ActivationImp::deleteProperty): Special case for arguments, refuse to delete. (ActivationImp::mark): Mark the arguments object. (ActivationImp::createArgumentsObject): Do the work of actually creating it. (GlobalFuncImp::call): Use stack-based objects for the ContextImp and ExecState.

• kjs/internal.h: Keep function and arguments pointer in the context.
• kjs/internal.cpp: (ContextImp::ContextImp): Don't pass in the func and args when making an ActivationImp. (InterpreterImp::evaluate): Use stack-based objects here.

• kjs/types.h: Add ArgumentList as a synonym for List, soon to be separate.

File:

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

trunk/JavaScriptCore/kjs/function.cpp

@@ -66 +66 @@
 }
 
-void FunctionImp::mark()
-{
-  InternalFunctionImp::mark();
-}
-
 bool FunctionImp::implementsCall() const
 {
@@ -99 +94 @@
   // enter a new execution context
   ContextImp ctx(globalObj, exec, thisObj, codeType(),
-                 exec->context().imp(), this, args);
+                 exec->context().imp(), this, &args);
   ExecState newExec(exec->interpreter(), &ctx);
   newExec.setException(exec->exception()); // could be null
@@ -211 +206 @@
         ContextImp *context = exec->_context;
         while (context) {
-            ActivationImp *activation = static_cast<ActivationImp *>(context->activationObject());
-            if (activation->function() == this)
-                return activation->get(exec, propertyName);
+            if (context->function() == this)
+                return static_cast<ActivationImp *>
+                    (context->activationObject())->get(exec, propertyName);
             context = context->callingContext();
         }
@@ -318 +313 @@
 
 // ECMA 10.1.8
+ArgumentsImp::ArgumentsImp(ExecState *exec, FunctionImp *func)
+  : ArrayInstanceImp(exec->interpreter()->builtinObjectPrototype().imp(), 0)
+{
+  Value protect(this);
+  putDirect(calleePropertyName, func, DontEnum);
+}
+
 ArgumentsImp::ArgumentsImp(ExecState *exec, FunctionImp *func, const List &args)
   : ArrayInstanceImp(exec->interpreter()->builtinObjectPrototype().imp(), args)
@@ -330 +332 @@
 
 // ECMA 10.1.6
-ActivationImp::ActivationImp(ExecState *exec, FunctionImp *f, const List &args)
-  : _function(f), _arguments(true)
-{
-  Value protect(this);
-  _arguments = args;
-  _argumentsObject = new ArgumentsImp(exec, f, args);
-  putDirect(argumentsPropertyName, _argumentsObject, Internal|DontDelete);
+ActivationImp::ActivationImp(ExecState *exec)
+    : _context(exec->context().imp()), _argumentsObject(0)
+{
+  // FIXME: Do we need to support enumerating the arguments property?
+}
+
+Value ActivationImp::get(ExecState *exec, const Identifier &propertyName) const
+{
+    if (propertyName == argumentsPropertyName) {
+        if (!_argumentsObject)
+            createArgumentsObject(exec);
+        return Value(_argumentsObject);
+    }
+    return ObjectImp::get(exec, propertyName);
+}
+
+void ActivationImp::put(ExecState *exec, const Identifier &propertyName, const Value &value, int attr)
+{
+    if (propertyName == argumentsPropertyName) {
+        // FIXME: Do we need to allow overwriting this?
+        return;
+    }
+    ObjectImp::put(exec, propertyName, value, attr);
+}
+
+bool ActivationImp::hasProperty(ExecState *exec, const Identifier &propertyName) const
+{
+    if (propertyName == argumentsPropertyName)
+        return true;
+    return ObjectImp::hasProperty(exec, propertyName);
+}
+
+bool ActivationImp::deleteProperty(ExecState *exec, const Identifier &propertyName)
+{
+    if (propertyName == argumentsPropertyName)
+        return false;
+    return ObjectImp::deleteProperty(exec, propertyName);
+}
+
+void ActivationImp::mark()
+{
+    if (_argumentsObject && !_argumentsObject->marked())
+        _argumentsObject->mark();
+    ObjectImp::mark();
+}
+
+void ActivationImp::createArgumentsObject(ExecState *exec) const
+{
+    FunctionImp *function = _context->function();
+    const ArgumentList *arguments = _context->arguments();
+    if (arguments)
+        _argumentsObject = new ArgumentsImp(exec, function, *arguments);
+    else
+        _argumentsObject = new ArgumentsImp(exec, function);
 }
 
@@ -392 +441 @@
       // enter a new execution context
       Object thisVal(Object::dynamicCast(exec->context().thisValue()));
-      ContextImp *ctx = new ContextImp(exec->interpreter()->globalObject(),
-                                       exec,
-                                       thisVal,
-                                       EvalCode,
-                                       exec->context().imp());
-
-      ExecState *newExec = new ExecState(exec->interpreter(),ctx);
-      newExec->setException(exec->exception()); // could be null
+      ContextImp ctx(exec->interpreter()->globalObject(),
+                     exec,
+                     thisVal,
+                     EvalCode,
+                     exec->context().imp());
+
+      ExecState newExec(exec->interpreter(), &ctx);
+      newExec.setException(exec->exception()); // could be null
 
       // execute the code
-      Completion c = progNode->execute(newExec);
+      Completion c = progNode->execute(&newExec);
 
       // if an exception occured, propogate it back to the previous execution object
-      if (newExec->hadException())
-        exec->setException(newExec->exception());
-      delete newExec;
-      delete ctx;
+      if (newExec.hadException())
+        exec->setException(newExec.exception());
 
       if ( progNode->deref() )