Changeset 27068 in webkit for trunk/JavaScriptCore/kjs

Timestamp:

Oct 25, 2007, 2:37:45 PM (18 years ago)

Author:

ggaren

Message:

Reviewed by Oliver Hunt.

Fixed ​http://bugs.webkit.org/show_bug.cgi?id=15694
Shrink the size of an activation object by 1 word

This is in preparation for adding a symbol table to the activation
object.

The basic strategy here is to rely on the mutual exclusion between
the arguments object pointer and the function pointer (you only need
the latter in order to create the former), and store them in the same
place. The LazyArgumentsObject class encapsulates this strategy.

Also inlined the ArgumentsImp constructor, for good measure.

SunSpider reports no regression. Regression tests pass.

• JavaScriptCore.xcodeproj/project.pbxproj:
• kjs/Context.cpp: (KJS::Context::~Context):
• kjs/function.cpp: (KJS::ActivationImp::LazyArgumentsObject::createArgumentsObject): (KJS::ActivationImp::LazyArgumentsObject::mark): (KJS::): (KJS::ActivationImp::argumentsGetter): (KJS::ActivationImp::mark):
• kjs/function.h: (KJS::ActivationImp::LazyArgumentsObject::LazyArgumentsObject): (KJS::ActivationImp::LazyArgumentsObject::getOrCreate): (KJS::ActivationImp::LazyArgumentsObject::resetArguments): (KJS::ActivationImp::LazyArgumentsObject::setArgumentsObject): (KJS::ActivationImp::LazyArgumentsObject::argumentsObject): (KJS::ActivationImp::LazyArgumentsObject::setFunction): (KJS::ActivationImp::LazyArgumentsObject::function): (KJS::ActivationImp::LazyArgumentsObject::createdArgumentsObject): (KJS::ActivationImp::LazyArgumentsObject::): (KJS::ActivationImp::ActivationImp::ActivationImp): (KJS::ActivationImp::resetArguments):

Location:

trunk/JavaScriptCore/kjs

Files:

• Context.cpp (modified) (1 diff)
• function.cpp (modified) (2 diffs)
• function.h (modified) (2 diffs)

trunk/JavaScriptCore/kjs/Context.cpp

@@ -88 +88 @@
     ActivationImp* activation = static_cast<ActivationImp*>(m_activation);
     if (activation)
-        activation->releaseArguments();
+        activation->resetArguments();
 }
 

trunk/JavaScriptCore/kjs/function.cpp

@@ -391 +391 @@
 // ------------------------------ ActivationImp --------------------------------
 
+void ActivationImp::LazyArgumentsObject::createArgumentsObject(ExecState* exec, ActivationImp* activationImp)
+{
+    setArgumentsObject(new Arguments(exec, function(), arguments, activationImp));
+
+    // 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.
+    arguments.reset();
+}
+
+void ActivationImp::LazyArgumentsObject::mark()
+{
+    JSObject* o;
+    if (createdArgumentsObject())
+        o = argumentsObject();
+    else
+        o = function();
+
+    if (!o->marked())
+        o->mark();
+}
+
 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?
-}
-
 JSValue* ActivationImp::argumentsGetter(ExecState* exec, JSObject*, const Identifier&, const PropertySlot& slot)
 {
   ActivationImp* thisObj = static_cast<ActivationImp*>(slot.slotBase());
-
-  // default: return builtin arguments array
-  if (!thisObj->_argumentsObject)
-    thisObj->createArgumentsObject(exec);
-  
-  return thisObj->_argumentsObject;
+  return thisObj->m_lazyArgumentsObject.getOrCreate(exec, thisObj);
 }
 
@@ -453 +463 @@
 void ActivationImp::mark()
 {
-    if (_function && !_function->marked()) 
-        _function->mark();
-    if (_argumentsObject && !_argumentsObject->marked())
-        _argumentsObject->mark();
+    m_lazyArgumentsObject.mark();
     JSObject::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();
 }
 

trunk/JavaScriptCore/kjs/function.h

@@ -144 +144 @@
   class ActivationImp : public JSObject {
   public:
-    ActivationImp(FunctionImp* function, const List& arguments);
+    class LazyArgumentsObject {
+    public:
+        LazyArgumentsObject(FunctionImp* f, const List& a)
+            : arguments(a)
+        {
+            ASSERT(f);
+            setFunction(f);
+        }
+
+        Arguments* getOrCreate(ExecState* exec, ActivationImp* activationImp)
+        {
+            if (!createdArgumentsObject())
+                createArgumentsObject(exec, activationImp);
+            return argumentsObject();
+        }
+
+        void resetArguments() { arguments.reset(); }
+        void mark();
+
+    private:
+        static const uintptr_t TagMask = 1; // Pointer alignment leaves this bit open for tagging.
+        
+        void setArgumentsObject(Arguments* a)
+        { 
+            u.argumentsObject = a;
+            u.bits |= TagMask;
+        }
+
+        Arguments* argumentsObject()
+        {
+            ASSERT(createdArgumentsObject());
+            return reinterpret_cast<Arguments*>(u.bits & ~TagMask);
+        }
+
+        void setFunction(FunctionImp* f) { u.function = f; }
+        FunctionImp* function()
+        {
+            ASSERT(!createdArgumentsObject());
+            return u.function;
+        }
+
+        bool createdArgumentsObject() { return (u.bits & TagMask) != 0; }
+        void createArgumentsObject(ExecState*, ActivationImp*);
+
+        List arguments;
+        union {
+            // The low bit in this union is a flag: 0 means the union holds a 
+            // FunctionImp*; 1 means the union holds an Arguments*.
+            uintptr_t bits;
+            FunctionImp* function;
+            Arguments* argumentsObject;
+        } u;
+    };
+    
+    ActivationImp::ActivationImp(FunctionImp* function, const List& arguments)
+        : m_lazyArgumentsObject(function, arguments)
+    {
+    }
 
     virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&);
@@ -157 +214 @@
     bool isActivation() { return true; }
 
-    void releaseArguments() { _arguments.reset(); }
+    void resetArguments() { m_lazyArgumentsObject.resetArguments(); }
 
   private:
     static PropertySlot::GetValueFunc getArgumentsGetter();
     static JSValue* argumentsGetter(ExecState*, JSObject*, const Identifier&, const PropertySlot& slot);
-    void createArgumentsObject(ExecState*);
-
-    FunctionImp* _function;
-    List _arguments;
-    mutable Arguments* _argumentsObject;
+    
+    LazyArgumentsObject m_lazyArgumentsObject;
   };